@proteos/sdk 0.18.1

package/dist/index.cjs

@@ -0,0 +1,2384 @@
+'use strict';
+
+var chunk7RGN4E22_cjs = require('./chunk-7RGN4E22.cjs');
+var zod = require('zod');
+var fetchEventSource = require('@microsoft/fetch-event-source');
+
+// src/agent/agents.ts
+var AGENTS_BASE_PATH = "/agents/v1/agents";
+var AgentServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", AGENTS_BASE_PATH, options);
+  }
+  async get(key) {
+    return this.client.request("GET", `${AGENTS_BASE_PATH}/${key}`);
+  }
+  async create(request) {
+    return this.client.request("POST", AGENTS_BASE_PATH, request);
+  }
+  async update(key, request) {
+    return this.client.request("PATCH", `${AGENTS_BASE_PATH}/${key}`, request);
+  }
+  async delete(key) {
+    await this.client.request("DELETE", `${AGENTS_BASE_PATH}/${key}`);
+  }
+};
+
+// src/agent/mcp-servers.ts
+var MCP_SERVERS_BASE_PATH = "/agents/v1/mcp-servers";
+var McpServerServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      MCP_SERVERS_BASE_PATH,
+      options
+    );
+  }
+  async get(key) {
+    return this.client.request("GET", `${MCP_SERVERS_BASE_PATH}/${key}`);
+  }
+  async create(request) {
+    return this.client.request("POST", MCP_SERVERS_BASE_PATH, request);
+  }
+  async update(key, request) {
+    return this.client.request("PATCH", `${MCP_SERVERS_BASE_PATH}/${key}`, request);
+  }
+  async delete(key) {
+    await this.client.request("DELETE", `${MCP_SERVERS_BASE_PATH}/${key}`);
+  }
+  async listTools(key) {
+    const response = await this.client.request(
+      "GET",
+      `${MCP_SERVERS_BASE_PATH}/${key}/tools`
+    );
+    return response.data;
+  }
+  async getConnectionStatus(key) {
+    const response = await this.client.request(
+      "GET",
+      `${MCP_SERVERS_BASE_PATH}/${key}/connection`
+    );
+    return response.data;
+  }
+  async startOAuth(key) {
+    return this.client.request(
+      "POST",
+      `${MCP_SERVERS_BASE_PATH}/${key}/oauth/connect`
+    );
+  }
+  async disconnectOAuth(key) {
+    await this.client.request("DELETE", `${MCP_SERVERS_BASE_PATH}/${key}/oauth/connect`);
+  }
+};
+
+// src/agent/prompts.ts
+var PROMPTS_BASE_PATH = "/agents/v1/prompts";
+var PromptServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", PROMPTS_BASE_PATH, options);
+  }
+  async get(key) {
+    return this.client.request("GET", `${PROMPTS_BASE_PATH}/${key}`);
+  }
+  async create(request) {
+    return this.client.request("POST", PROMPTS_BASE_PATH, request);
+  }
+  async update(key, request) {
+    return this.client.request("PATCH", `${PROMPTS_BASE_PATH}/${key}`, request);
+  }
+  async delete(key) {
+    await this.client.request("DELETE", `${PROMPTS_BASE_PATH}/${key}`);
+  }
+  async listVersions(key) {
+    const response = await this.client.request(
+      "GET",
+      `${PROMPTS_BASE_PATH}/${key}/versions`
+    );
+    return response.data;
+  }
+  async getVersion(key, number) {
+    return this.client.request(
+      "GET",
+      `${PROMPTS_BASE_PATH}/${key}/versions/${number}`
+    );
+  }
+};
+
+// src/agent/sessions.ts
+var SESSIONS_BASE_PATH = "/agents/v1/sessions";
+var SessionServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", SESSIONS_BASE_PATH, options);
+  }
+  async get(id) {
+    return this.client.request("GET", `${SESSIONS_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", SESSIONS_BASE_PATH, request);
+  }
+  async events(id, options = {}) {
+    const { types, ...rest } = options;
+    const query = {
+      ...rest,
+      ...types && types.length > 0 ? { types: types.join(",") } : {}
+    };
+    const response = await this.client.requestWithQuery(
+      "GET",
+      `${SESSIONS_BASE_PATH}/${id}/events`,
+      query
+    );
+    return response.data ?? [];
+  }
+  async appendEvent(id, request) {
+    return this.client.request("POST", `${SESSIONS_BASE_PATH}/${id}/events`, request);
+  }
+  async turns(id) {
+    const response = await this.client.request(
+      "GET",
+      `${SESSIONS_BASE_PATH}/${id}/turns`
+    );
+    return response.data ?? [];
+  }
+  async *stream(id, options = {}) {
+    const query = options.afterSeq ? `?after_seq=${options.afterSeq}` : "";
+    const path = `${SESSIONS_BASE_PATH}/${id}/events/stream${query}`;
+    const streamOptions = options.signal ? { signal: options.signal } : {};
+    for await (const frame of this.client.streamEvents(path, streamOptions)) {
+      const event = parseEvent(frame.data);
+      if (event) yield event;
+    }
+  }
+  async sendMessage(id, text, turnId) {
+    return this.sendUserMessage(id, { text, ...turnId ? { turnId } : {} });
+  }
+  async sendUserMessage(id, input) {
+    const content = [];
+    const text = input.text?.trim();
+    if (text) content.push({ type: "text", text });
+    for (const file of input.files ?? []) {
+      content.push({ type: "file", ...file });
+    }
+    return this.appendEvent(id, {
+      type: "user.message",
+      ...input.turnId ? { turn_id: input.turnId } : {},
+      payload: { content }
+    });
+  }
+  async interrupt(id) {
+    return this.appendEvent(id, { type: "user.interrupt" });
+  }
+  async submitToolResult(id, input) {
+    return this.appendEvent(id, {
+      type: "user.tool_result",
+      payload: {
+        tool_use_id: input.toolUseId,
+        result: input.result,
+        outcome: input.outcome ?? "success"
+      }
+    });
+  }
+};
+function parseEvent(data) {
+  if (!data) return null;
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+// src/agent/skills.ts
+var SKILLS_BASE_PATH = "/agents/v1/skills";
+var SkillServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", SKILLS_BASE_PATH, options);
+  }
+  async get(key) {
+    return this.client.request("GET", `${SKILLS_BASE_PATH}/${key}`);
+  }
+  async deploy(bundle, options) {
+    const formData = new FormData();
+    const filename = bundle instanceof File ? bundle.name : "skill.tar.gz";
+    formData.append("bundle", bundle, filename);
+    if (options?.displayName) {
+      formData.append("display_name", options.displayName);
+    }
+    if (options?.moduleSlug) {
+      formData.append("module_slug", options.moduleSlug);
+    }
+    return this.client.requestMultipart("POST", `${SKILLS_BASE_PATH}/deploy`, formData);
+  }
+  async delete(key) {
+    await this.client.request("DELETE", `${SKILLS_BASE_PATH}/${key}`);
+  }
+  async listVersions(key) {
+    const response = await this.client.request(
+      "GET",
+      `${SKILLS_BASE_PATH}/${key}/versions`
+    );
+    return response.data;
+  }
+  async getVersion(key, number) {
+    return this.client.request("GET", `${SKILLS_BASE_PATH}/${key}/versions/${number}`);
+  }
+};
+
+// src/agent/tools.ts
+var TOOLS_BASE_PATH = "/agents/v1/tools";
+var ToolServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", TOOLS_BASE_PATH, options);
+  }
+  async get(key) {
+    return this.client.request("GET", `${TOOLS_BASE_PATH}/${key}`);
+  }
+  async create(request) {
+    return this.client.request("POST", TOOLS_BASE_PATH, request);
+  }
+  async update(key, request) {
+    return this.client.request("PATCH", `${TOOLS_BASE_PATH}/${key}`, request);
+  }
+  async delete(key) {
+    await this.client.request("DELETE", `${TOOLS_BASE_PATH}/${key}`);
+  }
+};
+
+// src/agent/index.ts
+var AgentClient = class {
+  /** Service for managing agents. */
+  agents;
+  /** Service for managing prompts (versioned). */
+  prompts;
+  /** Service for managing skills (versioned bundles). */
+  skills;
+  /** Service for managing tools. */
+  tools;
+  /** Service for managing MCP server registrations. */
+  mcpServers;
+  /** Service for managing chat sessions (conversations + event log + stream). */
+  sessions;
+  /**
+   * Creates a new AgentClient instance.
+   *
+   * @param client - The base ProteosClient to use for API requests
+   */
+  constructor(client) {
+    this.agents = new AgentServiceImpl(client);
+    this.prompts = new PromptServiceImpl(client);
+    this.skills = new SkillServiceImpl(client);
+    this.tools = new ToolServiceImpl(client);
+    this.mcpServers = new McpServerServiceImpl(client);
+    this.sessions = new SessionServiceImpl(client);
+  }
+};
+
+// src/auth/me.ts
+var ME_BASE_PATH = "/accounts/v1/me";
+var MeServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async get() {
+    return this.client.request("GET", ME_BASE_PATH);
+  }
+  async organizations() {
+    const response = await this.client.request(
+      "GET",
+      `${ME_BASE_PATH}/organizations`
+    );
+    return response.data;
+  }
+};
+
+// src/auth/organizations.ts
+var ORGANIZATIONS_BASE_PATH = "/accounts/v1/organizations";
+var OrganizationServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      ORGANIZATIONS_BASE_PATH,
+      options
+    );
+  }
+  async get(id) {
+    return this.client.request("GET", `${ORGANIZATIONS_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", ORGANIZATIONS_BASE_PATH, request);
+  }
+  async update(id, request) {
+    return this.client.request("PATCH", `${ORGANIZATIONS_BASE_PATH}/${id}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${ORGANIZATIONS_BASE_PATH}/${id}`);
+  }
+};
+
+// src/auth/roles.ts
+var ROLES_BASE_PATH = "/accounts/v1/roles";
+var RoleServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", ROLES_BASE_PATH, options);
+  }
+  async get(slug) {
+    return this.client.request("GET", `${ROLES_BASE_PATH}/${slug}`);
+  }
+  async create(request) {
+    return this.client.request("POST", ROLES_BASE_PATH, request);
+  }
+  async upsert(slug, request) {
+    return this.client.request("PUT", `${ROLES_BASE_PATH}/${slug}`, { ...request, slug });
+  }
+  async update(slug, request) {
+    return this.client.request("PATCH", `${ROLES_BASE_PATH}/${slug}`, request);
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${ROLES_BASE_PATH}/${slug}`);
+  }
+  getPermissions(roleSlug, options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.fetchPermissionsPage(roleSlug, opts), options);
+  }
+  async assignPermission(roleSlug, request) {
+    return this.client.request(
+      "POST",
+      `${ROLES_BASE_PATH}/${roleSlug}/permissions`,
+      request
+    );
+  }
+  async removePermission(roleSlug, permissionId) {
+    await this.client.request(
+      "DELETE",
+      `${ROLES_BASE_PATH}/${roleSlug}/permissions/${permissionId}`
+    );
+  }
+  async fetchPermissionsPage(roleSlug, options) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${ROLES_BASE_PATH}/${roleSlug}/permissions`,
+      options
+    );
+  }
+};
+
+// src/auth/users.ts
+var USERS_BASE_PATH = "/accounts/v1/users";
+var UserServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", USERS_BASE_PATH, options);
+  }
+  async get(id) {
+    return this.client.request("GET", `${USERS_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", USERS_BASE_PATH, request);
+  }
+  async update(id, request) {
+    return this.client.request("PATCH", `${USERS_BASE_PATH}/${id}`, request);
+  }
+  getRoles(userId, options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.fetchRolesPage(userId, opts), options);
+  }
+  async assignRole(userId, request) {
+    return this.client.request(
+      "POST",
+      `${USERS_BASE_PATH}/${userId}/roles`,
+      request
+    );
+  }
+  async unassignRole(userId, roleSlug) {
+    await this.client.request("DELETE", `${USERS_BASE_PATH}/${userId}/roles/${roleSlug}`);
+  }
+  async listApiKeys(userId) {
+    const response = await this.client.request(
+      "GET",
+      `${USERS_BASE_PATH}/${userId}/api-keys`
+    );
+    return response.data;
+  }
+  async createApiKey(userId, request) {
+    return this.client.request(
+      "POST",
+      `${USERS_BASE_PATH}/${userId}/api-keys`,
+      request
+    );
+  }
+  async deleteApiKey(userId, keyId) {
+    await this.client.request("DELETE", `${USERS_BASE_PATH}/${userId}/api-keys/${keyId}`);
+  }
+  async fetchRolesPage(userId, options) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${USERS_BASE_PATH}/${userId}/roles`,
+      options
+    );
+  }
+};
+
+// src/auth/platform-entities.ts
+var PLATFORM_ENTITIES = [
+  // Access (account-service)
+  { slug: "organizations", name: "Organizations" },
+  { slug: "users", name: "Users" },
+  { slug: "roles", name: "Roles" },
+  { slug: "user-role-assignments", name: "User Role Assignments" },
+  { slug: "role-entity-permissions", name: "Role Entity Permissions" },
+  // Schema / content (metadata-service)
+  { slug: "entities", name: "Entities" },
+  { slug: "pages", name: "Pages" },
+  { slug: "menu-configurations", name: "Menu Configurations" },
+  { slug: "apps", name: "Apps" },
+  { slug: "components", name: "Components" },
+  { slug: "lists", name: "Lists" },
+  { slug: "list-views", name: "List Views" },
+  // System (metadata-service)
+  { slug: "modules", name: "Modules" },
+  { slug: "variables", name: "Variables" },
+  { slug: "deployments", name: "Deployments" },
+  // Storage (storage-service)
+  { slug: "files", name: "Files" },
+  // Automation (function-service)
+  { slug: "hooks", name: "Hooks" },
+  { slug: "actions", name: "Actions" },
+  // Knowledge (knowledge-service)
+  { slug: "knowledge-nodes", name: "Knowledge Nodes" },
+  { slug: "knowledge-links", name: "Knowledge Links" },
+  { slug: "knowledge-labels", name: "Knowledge Labels" },
+  // Agent suite (agent-service)
+  { slug: "agents", name: "Agents" },
+  { slug: "prompts", name: "Prompts" },
+  { slug: "skills", name: "Skills" },
+  { slug: "tools", name: "Tools" },
+  { slug: "mcp-servers", name: "MCP Servers" },
+  { slug: "agent-sessions", name: "Agent Sessions" },
+  // Messaging bus (event-service)
+  { slug: "topics", name: "Topics" },
+  { slug: "events", name: "Events" },
+  // Conversations (conversation-service). NOTE: `connections` is enforced by
+  // BOTH conversation-service and connector-service (2026-07 decision) — same
+  // concept in both; conversation connections migrate onto connector-service
+  // later.
+  { slug: "connections", name: "Connections" },
+  { slug: "conversations", name: "Conversations" },
+  { slug: "messages", name: "Messages" },
+  { slug: "agent-listeners", name: "Agent Listeners" },
+  { slug: "transcriptions", name: "Transcriptions" },
+  // Connectors (connector-service). `connections` above is shared; this is the
+  // manifest catalog.
+  { slug: "connectors", name: "Connectors" }
+];
+var PLATFORM_ENTITY_SLUGS = PLATFORM_ENTITIES.map(
+  (entity) => entity.slug
+);
+function isPlatformEntity(slug) {
+  return PLATFORM_ENTITY_SLUGS.includes(slug);
+}
+var RoleEntityPermissionSchema = chunk7RGN4E22_cjs.AuditFieldsSchema.extend({
+  id: zod.z.string(),
+  role_slug: zod.z.string(),
+  entity_slug: zod.z.string(),
+  permission: zod.z.enum(["read", "write", "delete"])
+});
+var UserRoleAssignmentSchema = chunk7RGN4E22_cjs.AuditFieldsSchema.extend({
+  id: zod.z.string(),
+  user_id: zod.z.string(),
+  role_slug: zod.z.string(),
+  org_id: zod.z.string()
+});
+var UserSchema = chunk7RGN4E22_cjs.AuditFieldsSchema.extend({
+  id: zod.z.string(),
+  email: zod.z.string(),
+  given_name: zod.z.string(),
+  family_name: zod.z.string(),
+  external_id: zod.z.string(),
+  default_org_id: zod.z.string()
+});
+chunk7RGN4E22_cjs.AuditFieldsSchema.extend({
+  id: zod.z.string(),
+  user_id: zod.z.string(),
+  org_id: zod.z.string(),
+  name: zod.z.string(),
+  token_prefix: zod.z.string(),
+  token_suffix: zod.z.string(),
+  expires_at: zod.z.string().nullable(),
+  last_used_at: zod.z.string().nullable()
+});
+var RoleSchema = chunk7RGN4E22_cjs.AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  org_id: zod.z.string(),
+  description: zod.z.string()
+});
+var OrganizationSchema = chunk7RGN4E22_cjs.AuditFieldsSchema.extend({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string()
+});
+
+// src/auth/index.ts
+var AccountClient = class {
+  /**
+   * Service for caller-scoped queries ("who am I", my organizations).
+   */
+  me;
+  /**
+   * Service for managing users and their role assignments.
+   */
+  users;
+  /**
+   * Service for managing roles and their entity permissions.
+   */
+  roles;
+  /**
+   * Service for managing organizations.
+   */
+  organizations;
+  /**
+   * Creates a new AccountClient instance.
+   *
+   * @param client - The base ProteosClient to use for API requests
+   */
+  constructor(client) {
+    this.me = new MeServiceImpl(client);
+    this.users = new UserServiceImpl(client);
+    this.roles = new RoleServiceImpl(client);
+    this.organizations = new OrganizationServiceImpl(client);
+  }
+};
+
+// src/errors.ts
+var ErrorCode = {
+  NOT_FOUND: "not_found",
+  UNAUTHORIZED: "unauthorized",
+  FORBIDDEN: "forbidden",
+  BAD_REQUEST: "bad_request",
+  CONFLICT: "conflict",
+  INTERNAL_SERVER_ERROR: "internal_server_error",
+  INVALID_PAYLOAD: "invalid_payload",
+  INVALID_PERSONA: "invalid_persona"
+};
+var ProteosError = class extends Error {
+  /** HTTP status code of the response */
+  httpStatus;
+  /** API error code (e.g., 'not_found', 'unauthorized') */
+  code;
+  constructor(message, httpStatus, code) {
+    super(message);
+    this.name = "ProteosError";
+    this.httpStatus = httpStatus;
+    this.code = code;
+    const v8Capture = Error.captureStackTrace;
+    if (v8Capture) v8Capture(this, this.constructor);
+  }
+  /**
+   * Returns a formatted string representation of the error.
+   */
+  toString() {
+    return `${this.code}: ${this.message} (HTTP ${this.httpStatus})`;
+  }
+};
+function isProteosError(error) {
+  return error instanceof ProteosError;
+}
+function isNotFound(error) {
+  return isProteosError(error) && error.httpStatus === 404;
+}
+function isUnauthorized(error) {
+  return isProteosError(error) && error.httpStatus === 401;
+}
+function isForbidden(error) {
+  return isProteosError(error) && error.httpStatus === 403;
+}
+function isBadRequest(error) {
+  return isProteosError(error) && error.httpStatus === 400;
+}
+function isConflict(error) {
+  return isProteosError(error) && error.httpStatus === 409;
+}
+function getDefaultErrorCode(httpStatus) {
+  switch (httpStatus) {
+    case 400:
+      return ErrorCode.BAD_REQUEST;
+    case 401:
+      return ErrorCode.UNAUTHORIZED;
+    case 403:
+      return ErrorCode.FORBIDDEN;
+    case 404:
+      return ErrorCode.NOT_FOUND;
+    case 409:
+      return ErrorCode.CONFLICT;
+    default:
+      return ErrorCode.INTERNAL_SERVER_ERROR;
+  }
+}
+async function parseErrorResponse(response) {
+  const httpStatus = response.status;
+  let code = getDefaultErrorCode(httpStatus);
+  let message = "Unknown error";
+  try {
+    const body = await response.text();
+    try {
+      const json = JSON.parse(body);
+      if (json.code) {
+        code = json.code;
+      }
+      if (json.message) {
+        message = json.message;
+      } else {
+        message = body || `HTTP ${httpStatus}`;
+      }
+    } catch {
+      message = body.trim() || `HTTP ${httpStatus}`;
+    }
+  } catch {
+    message = `HTTP ${httpStatus}`;
+  }
+  return new ProteosError(message, httpStatus, code);
+}
+
+// src/http/query-params.ts
+function toQueryParams(obj) {
+  const params = new URLSearchParams();
+  if (!obj) {
+    return params;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    appendQueryParam(params, key, value);
+  }
+  return params;
+}
+function appendQueryParam(params, key, value) {
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (item !== null && item !== void 0) {
+        params.append(key, String(item));
+      }
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    return;
+  }
+  params.set(key, String(value));
+}
+function toQueryString(params) {
+  const str = params.toString();
+  return str;
+}
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path, baseUrl);
+  if (query) {
+    const params = toQueryParams(query);
+    params.forEach((value, key) => {
+      url.searchParams.append(key, value);
+    });
+  }
+  return url.toString();
+}
+
+// src/types/options.ts
+var DEFAULT_OPTIONS = {
+  timeout: 3e4,
+  headers: {}
+};
+function resolveOptions(options) {
+  return {
+    baseUrl: options.baseUrl.replace(/\/$/, ""),
+    // Remove trailing slash
+    ...options.token !== void 0 ? { token: options.token } : {},
+    ...options.tokenProvider !== void 0 ? { tokenProvider: options.tokenProvider } : {},
+    timeout: options.timeout ?? DEFAULT_OPTIONS.timeout,
+    fetch: (options.fetch ?? globalThis.fetch).bind(globalThis),
+    headers: { ...DEFAULT_OPTIONS.headers, ...options.headers }
+  };
+}
+
+// src/client.ts
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+var ProteosClient = class {
+  options;
+  /**
+   * Creates a new ProteosClient instance.
+   *
+   * @param options - Client configuration options
+   *
+   * @example
+   * ```ts
+   * // With static token
+   * const client = new ProteosClient({
+   *   baseUrl: 'https://api.proteos.ai',
+   *   token: 'your-api-token',
+   * });
+   *
+   * // With dynamic token provider
+   * const client = new ProteosClient({
+   *   baseUrl: 'https://api.proteos.ai',
+   *   tokenProvider: async () => {
+   *     return await authService.getAccessToken();
+   *   },
+   * });
+   * ```
+   */
+  constructor(options) {
+    this.options = resolveOptions(options);
+  }
+  /**
+   * Returns the base URL configured for this client.
+   */
+  get baseUrl() {
+    return this.options.baseUrl;
+  }
+  /**
+   * Gets the current authentication token.
+   * Calls tokenProvider if available, otherwise returns static token.
+   */
+  async getToken() {
+    if (this.options.tokenProvider) {
+      return await this.options.tokenProvider();
+    }
+    return this.options.token;
+  }
+  /**
+   * Builds the headers for a request.
+   */
+  async buildHeaders(requestOptions) {
+    const headers = new Headers({
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...this.options.headers,
+      ...requestOptions?.headers
+    });
+    const token = await this.getToken();
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    return headers;
+  }
+  /**
+   * Creates an AbortSignal with timeout.
+   */
+  createTimeoutSignal(requestOptions) {
+    const timeout = requestOptions?.timeout ?? this.options.timeout;
+    if (requestOptions?.signal) {
+      const controller = new AbortController();
+      requestOptions.signal.addEventListener("abort", () => {
+        controller.abort(requestOptions.signal?.reason);
+      });
+      const timeoutId = setTimeout(() => {
+        controller.abort(new Error(`Request timeout after ${timeout}ms`));
+      }, timeout);
+      controller.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+      });
+      return controller.signal;
+    }
+    return AbortSignal.timeout(timeout);
+  }
+  /**
+   * Performs an HTTP request and decodes the JSON response.
+   *
+   * @param method - HTTP method (GET, POST, PATCH, DELETE, etc.)
+   * @param path - Request path (appended to baseUrl)
+   * @param body - Request body (will be JSON-serialized)
+   * @param requestOptions - Optional request configuration
+   * @returns Decoded response body
+   * @throws {ProteosError} If the response status is >= 400
+   */
+  async request(method, path, body, requestOptions) {
+    return this.requestWithQuery(method, path, void 0, body, requestOptions);
+  }
+  /**
+   * Performs an HTTP request with query parameters.
+   *
+   * @param method - HTTP method
+   * @param path - Request path
+   * @param query - Query parameters object
+   * @param body - Request body
+   * @param requestOptions - Optional request configuration
+   * @returns Decoded response body
+   * @throws {ProteosError} If the response status is >= 400
+   */
+  async requestWithQuery(method, path, query, body, requestOptions) {
+    let url = `${this.options.baseUrl}${path}`;
+    if (query) {
+      const params = toQueryParams(query);
+      const queryString = params.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const headers = await this.buildHeaders(requestOptions);
+    const signal = this.createTimeoutSignal(requestOptions);
+    const response = await this.options.fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : null,
+      signal
+    });
+    if (response.status >= 400) {
+      throw await parseErrorResponse(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new ProteosError(
+        `Failed to parse response as JSON: ${text.slice(0, 100)}`,
+        response.status,
+        "parse_error"
+      );
+    }
+  }
+  /**
+   * Performs a multipart form request (for file uploads).
+   *
+   * @param method - HTTP method
+   * @param path - Request path
+   * @param formData - FormData instance with files and fields
+   * @param requestOptions - Optional request configuration
+   * @returns Decoded response body
+   * @throws {ProteosError} If the response status is >= 400
+   */
+  async requestMultipart(method, path, formData, requestOptions) {
+    const url = `${this.options.baseUrl}${path}`;
+    const headers = new Headers({
+      Accept: "application/json",
+      ...this.options.headers,
+      ...requestOptions?.headers
+    });
+    const token = await this.getToken();
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    const signal = this.createTimeoutSignal(requestOptions);
+    const response = await this.options.fetch(url, {
+      method,
+      headers,
+      body: formData,
+      signal
+    });
+    if (response.status >= 400) {
+      throw await parseErrorResponse(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return await response.json();
+  }
+  /**
+   * Performs an HTTP request and returns the raw response.
+   * Used for downloading files or streaming responses.
+   *
+   * @param method - HTTP method
+   * @param path - Request path
+   * @param body - Request body
+   * @param requestOptions - Optional request configuration
+   * @returns Object with response body stream and full Response object
+   * @throws {ProteosError} If the response status is >= 400
+   */
+  async requestRaw(method, path, body, requestOptions) {
+    const url = `${this.options.baseUrl}${path}`;
+    const headers = await this.buildHeaders(requestOptions);
+    const signal = this.createTimeoutSignal(requestOptions);
+    const response = await this.options.fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : null,
+      signal
+    });
+    if (response.status >= 400) {
+      throw await parseErrorResponse(response);
+    }
+    return {
+      body: response.body,
+      response
+    };
+  }
+  /**
+   * Opens a Server-Sent-Events stream and yields each frame as it arrives.
+   *
+   * Built on `@microsoft/fetch-event-source` (not the browser-native
+   * `EventSource`, which can't set an `Authorization` header) so the bearer token
+   * is attached like any other request. The library tracks `Last-Event-ID` and
+   * reconnects with exponential backoff on transient errors; a 4xx is fatal and
+   * rejects. The stream runs until the caller's `AbortSignal` fires.
+   *
+   * The token is resolved once at stream start; teardown is the caller's signal.
+   *
+   * @param path - Request path (appended to baseUrl)
+   * @param requestOptions - Optional request configuration (signal)
+   * @returns Async generator of parsed {@link SseFrame}s
+   * @throws {ProteosError} On a non-retryable (4xx) response
+   */
+  async *streamEvents(path, requestOptions) {
+    const url = `${this.options.baseUrl}${path}`;
+    const headers = { ...this.options.headers };
+    const token = await this.getToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let failure;
+    const notify = () => {
+      wake?.();
+      wake = null;
+    };
+    const push = (frame) => {
+      queue.push(frame);
+      notify();
+    };
+    const finish = (error) => {
+      if (error !== void 0) failure = error;
+      finished = true;
+      notify();
+    };
+    const controller = new AbortController();
+    const onExternalAbort = () => controller.abort();
+    if (requestOptions?.signal) {
+      if (requestOptions.signal.aborted) controller.abort();
+      else requestOptions.signal.addEventListener("abort", onExternalAbort, { once: true });
+    }
+    const streaming = fetchEventSource.fetchEventSource(url, {
+      method: "GET",
+      headers,
+      signal: controller.signal,
+      fetch: this.options.fetch,
+      // Keep streaming when the tab is backgrounded (default would disconnect).
+      openWhenHidden: true,
+      onopen: async (response) => {
+        if (response.status >= 400) {
+          throw await parseErrorResponse(response);
+        }
+      },
+      onmessage: (message) => {
+        push({
+          id: message.id || void 0,
+          event: message.event || void 0,
+          data: message.data
+        });
+      },
+      onerror: (error) => {
+        if (isAbortError(error)) throw error;
+        if (error instanceof ProteosError && error.httpStatus >= 400 && error.httpStatus < 500) {
+          throw error;
+        }
+        return 2e3;
+      }
+    }).then(() => finish()).catch((error) => finish(error));
+    try {
+      while (true) {
+        if (queue.length > 0) {
+          yield queue.shift();
+          continue;
+        }
+        if (finished) break;
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      if (failure !== void 0 && !isAbortError(failure)) throw failure;
+    } finally {
+      controller.abort();
+      requestOptions?.signal?.removeEventListener("abort", onExternalAbort);
+      await streaming.catch(() => {
+      });
+    }
+  }
+  /**
+   * Opens an authenticated WebSocket to a service path and resolves once it is
+   * open.
+   *
+   * The browser-native `WebSocket` can't set an `Authorization` header, so the
+   * access token is passed via the `bearer` subprotocol (`["bearer", token]`),
+   * which the gateway lifts back into the auth header — the same token resolved
+   * for every other request. The `http(s)` base URL is rewritten to `ws(s)`.
+   *
+   * @param path - Request path (appended to baseUrl), including any query string
+   * @returns The open WebSocket
+   */
+  async openWebSocket(path) {
+    const wsBaseUrl = this.options.baseUrl.replace(/^http/, "ws");
+    const url = `${wsBaseUrl}${path}`;
+    const token = await this.getToken();
+    const socket = token ? new WebSocket(url, ["bearer", token]) : new WebSocket(url);
+    await new Promise((resolve, reject) => {
+      socket.onopen = () => resolve();
+      socket.onerror = () => reject(new ProteosError("WebSocket connection failed", 0, "ws_error"));
+    });
+    socket.onopen = null;
+    socket.onerror = null;
+    return socket;
+  }
+};
+
+// src/conversation/voice.ts
+var VOICE_BASE_PATH = "/conversations/v1/voice";
+var VoiceServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async transcribeStream(options) {
+    const query = buildQuery(options);
+    const socket = await this.client.openWebSocket(`${VOICE_BASE_PATH}/transcribe/stream${query}`);
+    socket.binaryType = "arraybuffer";
+    socket.onmessage = (event) => {
+      if (typeof event.data !== "string") return;
+      try {
+        options.onResult(JSON.parse(event.data));
+      } catch {
+      }
+    };
+    if (options.onError) socket.onerror = options.onError;
+    socket.onclose = () => options.onClose?.();
+    const isOpen = () => socket.readyState === WebSocket.OPEN;
+    return {
+      sendAudio: (chunk) => {
+        if (isOpen()) socket.send(chunk);
+      },
+      finalize: () => {
+        if (isOpen()) socket.send(JSON.stringify({ type: "finalize" }));
+      },
+      close: () => socket.close()
+    };
+  }
+};
+function buildQuery(options) {
+  const params = new URLSearchParams();
+  if (options.language) params.set("language", options.language);
+  if (options.interimResults !== void 0)
+    params.set("interim_results", String(options.interimResults));
+  if (options.punctuate !== void 0) params.set("punctuate", String(options.punctuate));
+  if (options.smartFormat !== void 0) params.set("smart_format", String(options.smartFormat));
+  if (options.encoding) params.set("encoding", options.encoding);
+  if (options.sampleRate !== void 0) params.set("sample_rate", String(options.sampleRate));
+  const queryString = params.toString();
+  return queryString ? `?${queryString}` : "";
+}
+
+// src/conversation/index.ts
+var CONVERSATION_BASE_PATH = "/conversations/v1";
+var ConversationClient = class {
+  connections;
+  conversations;
+  messages;
+  agentListeners;
+  transcriptions;
+  /** Realtime speech-to-text (dictation) — moved here from agent-service. */
+  voice;
+  constructor(client) {
+    this.connections = new ConnectionServiceImpl(client);
+    this.conversations = new ConversationServiceImpl(client);
+    this.messages = new MessageServiceImpl(client);
+    this.agentListeners = new AgentListenerServiceImpl(client);
+    this.transcriptions = new TranscriptionServiceImpl(client);
+    this.voice = new VoiceServiceImpl(client);
+  }
+};
+var ConnectionServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(query = {}) {
+    return this.client.requestWithQuery("GET", `${CONVERSATION_BASE_PATH}/connections`, query);
+  }
+  get(id) {
+    return this.client.request("GET", `${CONVERSATION_BASE_PATH}/connections/${encodeURIComponent(id)}`);
+  }
+  create(request) {
+    return this.client.request("POST", `${CONVERSATION_BASE_PATH}/connections`, request);
+  }
+  update(id, request) {
+    return this.client.request("PATCH", `${CONVERSATION_BASE_PATH}/connections/${encodeURIComponent(id)}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${CONVERSATION_BASE_PATH}/connections/${encodeURIComponent(id)}`);
+  }
+  install(id) {
+    return this.client.request("POST", `${CONVERSATION_BASE_PATH}/connections/${encodeURIComponent(id)}/install`);
+  }
+  listParticipants(connectionId, query = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${CONVERSATION_BASE_PATH}/connections/${encodeURIComponent(connectionId)}/participants`,
+      query
+    );
+  }
+  listRooms(connectionId, query = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${CONVERSATION_BASE_PATH}/connections/${encodeURIComponent(connectionId)}/rooms`,
+      query
+    );
+  }
+};
+var ConversationServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(query = {}) {
+    return this.client.requestWithQuery("GET", `${CONVERSATION_BASE_PATH}/conversations`, query);
+  }
+  get(id) {
+    return this.client.request("GET", `${CONVERSATION_BASE_PATH}/conversations/${encodeURIComponent(id)}`);
+  }
+  end(id) {
+    return this.client.request("POST", `${CONVERSATION_BASE_PATH}/conversations/${encodeURIComponent(id)}/end`);
+  }
+  markRead(id) {
+    return this.client.request("POST", `${CONVERSATION_BASE_PATH}/conversations/${encodeURIComponent(id)}/read`);
+  }
+  markUnread(id) {
+    return this.client.request("DELETE", `${CONVERSATION_BASE_PATH}/conversations/${encodeURIComponent(id)}/read`);
+  }
+  unreadCounts() {
+    return this.client.request("GET", `${CONVERSATION_BASE_PATH}/conversations/unread-counts`);
+  }
+};
+var MessageServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  listByConversation(conversationId, query = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${CONVERSATION_BASE_PATH}/conversations/${encodeURIComponent(conversationId)}/messages`,
+      query
+    );
+  }
+  send(request) {
+    return this.client.request("POST", `${CONVERSATION_BASE_PATH}/messages/send`, request);
+  }
+  async getReactions(messageId) {
+    const response = await this.client.request(
+      "GET",
+      `${CONVERSATION_BASE_PATH}/messages/${encodeURIComponent(messageId)}/reactions`
+    );
+    return response.data;
+  }
+  async addReaction(messageId, emoji) {
+    const response = await this.client.request(
+      "POST",
+      `${CONVERSATION_BASE_PATH}/messages/${encodeURIComponent(messageId)}/reactions`,
+      { emoji }
+    );
+    return response.data;
+  }
+  async removeReaction(messageId, emoji) {
+    const response = await this.client.request(
+      "DELETE",
+      `${CONVERSATION_BASE_PATH}/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(emoji)}`
+    );
+    return response.data;
+  }
+};
+var AgentListenerServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(query = {}) {
+    return this.client.requestWithQuery("GET", `${CONVERSATION_BASE_PATH}/agent-listeners`, query);
+  }
+  get(id) {
+    return this.client.request("GET", `${CONVERSATION_BASE_PATH}/agent-listeners/${encodeURIComponent(id)}`);
+  }
+  create(request) {
+    return this.client.request("POST", `${CONVERSATION_BASE_PATH}/agent-listeners`, request);
+  }
+  update(id, request) {
+    return this.client.request("PATCH", `${CONVERSATION_BASE_PATH}/agent-listeners/${encodeURIComponent(id)}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${CONVERSATION_BASE_PATH}/agent-listeners/${encodeURIComponent(id)}`);
+  }
+};
+var TranscriptionServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  createFromFile(request) {
+    return this.client.request("POST", `${CONVERSATION_BASE_PATH}/transcriptions`, request);
+  }
+  list(query = {}) {
+    return this.client.requestWithQuery("GET", `${CONVERSATION_BASE_PATH}/transcriptions`, query);
+  }
+  get(id) {
+    return this.client.request("GET", `${CONVERSATION_BASE_PATH}/transcriptions/${encodeURIComponent(id)}`);
+  }
+  materialize(id, request = {}) {
+    return this.client.request(
+      "POST",
+      `${CONVERSATION_BASE_PATH}/transcriptions/${encodeURIComponent(id)}/materialize`,
+      request
+    );
+  }
+};
+
+// src/connector/index.ts
+var CONNECTOR_BASE_PATH = "/connectors/v1";
+var ConnectorClient = class {
+  connectors;
+  connections;
+  constructor(client) {
+    this.connectors = new ConnectorCatalogServiceImpl(client);
+    this.connections = new ConnectorConnectionServiceImpl(client);
+  }
+};
+var ConnectorCatalogServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(query = {}) {
+    return this.client.requestWithQuery("GET", `${CONNECTOR_BASE_PATH}/connectors`, query);
+  }
+  get(key) {
+    return this.client.request("GET", `${CONNECTOR_BASE_PATH}/connectors/${encodeURIComponent(key)}`);
+  }
+  async listMethods(key) {
+    const connector = await this.get(key);
+    return connector.methods ?? [];
+  }
+};
+var ConnectorConnectionServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(query = {}) {
+    return this.client.requestWithQuery("GET", `${CONNECTOR_BASE_PATH}/connections`, query);
+  }
+  get(id) {
+    return this.client.request("GET", `${CONNECTOR_BASE_PATH}/connections/${encodeURIComponent(id)}`);
+  }
+  create(request) {
+    return this.client.request("POST", `${CONNECTOR_BASE_PATH}/connections`, request);
+  }
+  update(id, request) {
+    return this.client.request("PATCH", `${CONNECTOR_BASE_PATH}/connections/${encodeURIComponent(id)}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${CONNECTOR_BASE_PATH}/connections/${encodeURIComponent(id)}`);
+  }
+  install(id) {
+    return this.client.request("POST", `${CONNECTOR_BASE_PATH}/connections/${encodeURIComponent(id)}/install`);
+  }
+  token(id) {
+    return this.client.request("POST", `${CONNECTOR_BASE_PATH}/connections/${encodeURIComponent(id)}/token`);
+  }
+  async invokeMethod(id, method, params = {}) {
+    const response = await this.client.request(
+      "POST",
+      `${CONNECTOR_BASE_PATH}/connections/${encodeURIComponent(id)}/methods/${encodeURIComponent(method)}/invoke`,
+      params
+    );
+    return response.result;
+  }
+};
+
+// src/data/queries.ts
+var QUERY_BASE_PATH = "/data/v1/query";
+var QueryServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async execute(sql) {
+    return this.client.request("POST", `${QUERY_BASE_PATH}/execute`, { sql });
+  }
+  async validate(sql) {
+    return this.client.request("POST", `${QUERY_BASE_PATH}/validate`, {
+      sql
+    });
+  }
+};
+
+// src/data/records.ts
+var RECORDS_BASE_PATH = "/data/v1/records";
+var BATCH_RECORDS_BASE_PATH = "/data/v1/batch/records";
+var RecordServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(entitySlug, options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(entitySlug, opts), options);
+  }
+  async listPage(entitySlug, options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${RECORDS_BASE_PATH}/${entitySlug}`,
+      options
+    );
+  }
+  async get(entitySlug, id) {
+    return this.client.request("GET", `${RECORDS_BASE_PATH}/${entitySlug}/${id}`);
+  }
+  async create(entitySlug, data) {
+    return this.client.request("POST", `${RECORDS_BASE_PATH}/${entitySlug}`, data);
+  }
+  async update(entitySlug, id, data) {
+    return this.client.request(
+      "PATCH",
+      `${RECORDS_BASE_PATH}/${entitySlug}/${id}`,
+      data
+    );
+  }
+  async delete(entitySlug, id) {
+    await this.client.request("DELETE", `${RECORDS_BASE_PATH}/${entitySlug}/${id}`);
+  }
+  async batchUpsert(entitySlug, transactions) {
+    return this.client.request(
+      "POST",
+      `${BATCH_RECORDS_BASE_PATH}/${entitySlug}/upsert`,
+      transactions
+    );
+  }
+};
+var BatchUpsertTransactionSchema = zod.z.object({
+  transaction_id: zod.z.string(),
+  data: zod.z.record(zod.z.unknown())
+});
+var BatchTransactionErrorSchema = zod.z.object({
+  code: zod.z.string(),
+  message: zod.z.string()
+});
+var BatchUpsertTransactionResultSchema = zod.z.object({
+  transaction_id: zod.z.string(),
+  status: zod.z.enum(["success", "error"]),
+  record: zod.z.record(zod.z.unknown()).optional(),
+  error: BatchTransactionErrorSchema.optional()
+});
+var BatchUpsertRecordsResponseSchema = zod.z.object({
+  results: zod.z.array(BatchUpsertTransactionResultSchema)
+});
+
+// src/data/index.ts
+var DataClient = class {
+  records;
+  queries;
+  constructor(client) {
+    this.records = new RecordServiceImpl(client);
+    this.queries = new QueryServiceImpl(client);
+  }
+};
+
+// src/events/index.ts
+var EVENTS_BASE_PATH = "/events/v1";
+var TAIL_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
+var EventsClient = class {
+  topics;
+  constructor(client) {
+    this.topics = new TopicServiceImpl(client);
+  }
+};
+var TopicServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list() {
+    const response = await this.client.request(
+      "GET",
+      `${EVENTS_BASE_PATH}/topics`
+    );
+    return response.data ?? [];
+  }
+  async events(topic, options = {}) {
+    const response = await this.client.requestWithQuery(
+      "GET",
+      `${EVENTS_BASE_PATH}/topics/${encodeURIComponent(topic)}/events`,
+      options
+    );
+    return response.data ?? [];
+  }
+  async *tail(topic, options = {}) {
+    const path = `${EVENTS_BASE_PATH}/topics/${encodeURIComponent(topic)}/events?follow=true`;
+    let body;
+    try {
+      ;
+      ({ body } = await this.client.requestRaw("GET", path, void 0, {
+        timeout: TAIL_TIMEOUT_MS,
+        ...options.signal ? { signal: options.signal } : {},
+        headers: { Accept: "application/x-ndjson" }
+      }));
+    } catch (error) {
+      if (isAbort(error)) return;
+      throw error;
+    }
+    if (!body) return;
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+          const line = buffer.slice(0, newlineIndex).trim();
+          buffer = buffer.slice(newlineIndex + 1);
+          const event = parseLine(line);
+          if (event) yield event;
+          newlineIndex = buffer.indexOf("\n");
+        }
+      }
+      const remainder = parseLine(buffer.trim());
+      if (remainder) yield remainder;
+    } catch (error) {
+      if (!isAbort(error)) throw error;
+    } finally {
+      reader.releaseLock();
+      void body.cancel().catch(() => {
+      });
+    }
+  }
+  async publish(topic, request) {
+    return this.client.request(
+      "POST",
+      `${EVENTS_BASE_PATH}/topics/${encodeURIComponent(topic)}/events`,
+      request
+    );
+  }
+  async redrive(topic) {
+    return this.client.request(
+      "POST",
+      `${EVENTS_BASE_PATH}/topics/${encodeURIComponent(topic)}/redrive`
+    );
+  }
+  async purge(topic) {
+    await this.client.request(
+      "POST",
+      `${EVENTS_BASE_PATH}/topics/${encodeURIComponent(topic)}/purge`
+    );
+  }
+};
+function isAbort(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function parseLine(line) {
+  if (!line) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+// src/functions/actions.ts
+var ACTIONS_BASE_PATH = "/functions/v1/actions";
+var ActionServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", ACTIONS_BASE_PATH, options);
+  }
+  async get(slug) {
+    return this.client.request("GET", `${ACTIONS_BASE_PATH}/${slug}`);
+  }
+  async invokeGlobal(slug, params) {
+    const response = await this.client.request(
+      "POST",
+      `${ACTIONS_BASE_PATH}/${slug}/invoke`,
+      params
+    );
+    return response.result;
+  }
+  async invokeEntity(entitySlug, recordId, slug, params) {
+    const response = await this.client.request(
+      "POST",
+      `/functions/v1/entities/${entitySlug}/records/${recordId}/actions/${slug}/invoke`,
+      params
+    );
+    return response.result;
+  }
+};
+var ActionScopeSchema = zod.z.enum(["entity", "global"]);
+var ActionSchema = chunk7RGN4E22_cjs.AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  org_id: zod.z.string(),
+  module_slug: zod.z.string(),
+  scope: ActionScopeSchema,
+  entity: zod.z.string().optional(),
+  name: zod.z.string(),
+  is_active: zod.z.boolean(),
+  file_id: zod.z.string(),
+  params: zod.z.array(chunk7RGN4E22_cjs.AttributeSchema),
+  returns: zod.z.array(chunk7RGN4E22_cjs.AttributeSchema)
+});
+
+// src/functions/index.ts
+var FunctionsClient = class {
+  actions;
+  constructor(client) {
+    this.actions = new ActionServiceImpl(client);
+  }
+};
+
+// src/knowledge/graph.ts
+var GRAPH_BASE_PATH = "/knowledge/v1/graph";
+var GraphServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async get(options = {}) {
+    const query = {};
+    if (options.label_ids && options.label_ids.length > 0) {
+      query.label_ids = options.label_ids.join(",");
+    }
+    return this.client.requestWithQuery("GET", GRAPH_BASE_PATH, query);
+  }
+};
+
+// src/knowledge/labels.ts
+var LABELS_BASE_PATH = "/knowledge/v1/labels";
+var LabelServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      LABELS_BASE_PATH,
+      options
+    );
+  }
+  async get(id) {
+    return this.client.request("GET", `${LABELS_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", LABELS_BASE_PATH, request);
+  }
+  async update(id, request) {
+    return this.client.request("PATCH", `${LABELS_BASE_PATH}/${id}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${LABELS_BASE_PATH}/${id}`);
+  }
+};
+
+// src/knowledge/links.ts
+var LINKS_BASE_PATH = "/knowledge/v1/links";
+var LinkServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", LINKS_BASE_PATH, options);
+  }
+  async get(id) {
+    return this.client.request("GET", `${LINKS_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", LINKS_BASE_PATH, request);
+  }
+  async update(id, request) {
+    return this.client.request("PATCH", `${LINKS_BASE_PATH}/${id}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${LINKS_BASE_PATH}/${id}`);
+  }
+};
+
+// src/knowledge/nodes.ts
+var NODES_BASE_PATH = "/knowledge/v1/nodes";
+var NodeServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    const { label_ids, ...rest } = options;
+    const query = { ...rest };
+    if (label_ids && label_ids.length > 0) {
+      query.label_ids = label_ids.join(",");
+    }
+    return this.client.requestWithQuery(
+      "GET",
+      NODES_BASE_PATH,
+      query
+    );
+  }
+  async get(id) {
+    return this.client.request("GET", `${NODES_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", NODES_BASE_PATH, request);
+  }
+  async update(id, request) {
+    return this.client.request("PATCH", `${NODES_BASE_PATH}/${id}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${NODES_BASE_PATH}/${id}`);
+  }
+  async search(request) {
+    return this.client.request(
+      "POST",
+      `${NODES_BASE_PATH}/actions/search`,
+      request
+    );
+  }
+  async neighbors(id, options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${NODES_BASE_PATH}/${id}/neighbors`,
+      options
+    );
+  }
+  async getContent(id) {
+    return this.client.request("GET", `${NODES_BASE_PATH}/${id}/content`);
+  }
+  async writeContent(id, content) {
+    return this.client.request("PUT", `${NODES_BASE_PATH}/${id}/content`, {
+      content
+    });
+  }
+  async editContent(id, request) {
+    return this.client.request(
+      "POST",
+      `${NODES_BASE_PATH}/${id}/content/actions/edit`,
+      request
+    );
+  }
+  async getOutline(request) {
+    return this.client.request(
+      "POST",
+      `${NODES_BASE_PATH}/content/actions/outline`,
+      request
+    );
+  }
+  async searchContent(request) {
+    return this.client.request(
+      "POST",
+      `${NODES_BASE_PATH}/content/actions/search`,
+      request
+    );
+  }
+  async listLabels(id) {
+    const result = await this.client.request(
+      "GET",
+      `${NODES_BASE_PATH}/${id}/labels`
+    );
+    return result.data;
+  }
+  async attachLabel(id, labelId) {
+    return this.client.request("POST", `${NODES_BASE_PATH}/${id}/labels`, {
+      label_id: labelId
+    });
+  }
+  async detachLabel(id, labelId) {
+    await this.client.request("DELETE", `${NODES_BASE_PATH}/${id}/labels/${labelId}`);
+  }
+};
+
+// src/knowledge/record-links.ts
+var RECORD_LINKS_BASE_PATH = "/knowledge/v1/record-links";
+var RecordLinkServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      RECORD_LINKS_BASE_PATH,
+      options
+    );
+  }
+  async get(id) {
+    return this.client.request("GET", `${RECORD_LINKS_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", RECORD_LINKS_BASE_PATH, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${RECORD_LINKS_BASE_PATH}/${id}`);
+  }
+};
+var KnowledgeNodeMetadataSchema = zod.z.object({
+  id: zod.z.string(),
+  org_id: zod.z.string(),
+  title: zod.z.string(),
+  type: zod.z.enum(["markdown", "file", "url"]),
+  status: zod.z.enum(["draft", "published", "archived"]),
+  embedding_model: zod.z.string().nullish(),
+  embedded_at: zod.z.string().nullish(),
+  file_id: zod.z.string().nullish(),
+  url: zod.z.string().nullish(),
+  summary: zod.z.string().nullish(),
+  valid_from: zod.z.string().nullish(),
+  valid_until: zod.z.string().nullish()
+}).merge(chunk7RGN4E22_cjs.AuditFieldsSchema);
+var KnowledgeNodeSchema = KnowledgeNodeMetadataSchema.extend({
+  content: zod.z.string()
+});
+var KnowledgeNodeSearchResultSchema = KnowledgeNodeMetadataSchema.extend({
+  score: zod.z.number()
+});
+var KnowledgeLinkSchema = zod.z.object({
+  id: zod.z.string(),
+  org_id: zod.z.string(),
+  from_id: zod.z.string(),
+  to_id: zod.z.string(),
+  type: zod.z.enum([
+    "references",
+    "relates_to",
+    "depends_on",
+    "part_of",
+    "derived_from",
+    "contradicts",
+    "supports",
+    "duplicates",
+    "superseded_by"
+  ]),
+  description: zod.z.string().nullish()
+}).merge(chunk7RGN4E22_cjs.AuditFieldsSchema);
+var KnowledgeRecordLinkSchema = zod.z.object({
+  id: zod.z.string(),
+  org_id: zod.z.string(),
+  node_id: zod.z.string(),
+  entity_slug: zod.z.string(),
+  record_id: zod.z.string(),
+  created_at: zod.z.string(),
+  created_by: chunk7RGN4E22_cjs.UserRefSchema
+});
+var KnowledgeLabelSchema = zod.z.object({
+  id: zod.z.string(),
+  org_id: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  description: zod.z.string().nullish(),
+  color: zod.z.string().nullish(),
+  icon: zod.z.string().nullish()
+}).merge(chunk7RGN4E22_cjs.AuditFieldsSchema);
+var KnowledgeNodeLabelSchema = zod.z.object({
+  org_id: zod.z.string(),
+  node_id: zod.z.string(),
+  label_id: zod.z.string(),
+  created_at: zod.z.string(),
+  created_by: chunk7RGN4E22_cjs.UserRefSchema
+});
+var NodeNeighborhoodSchema = zod.z.object({
+  nodes: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      title: zod.z.string(),
+      type: zod.z.enum(["markdown", "file", "url"]),
+      status: zod.z.enum(["draft", "published", "archived"]),
+      distance: zod.z.number()
+    })
+  ),
+  edges: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      from_id: zod.z.string(),
+      to_id: zod.z.string(),
+      type: zod.z.string()
+    })
+  )
+});
+
+// src/knowledge/index.ts
+var KnowledgeClient = class {
+  nodes;
+  links;
+  /** Node→record edges (links to data-service records): `knowledge.recordLinks`. */
+  recordLinks;
+  labels;
+  /** Whole-org graph bulk read (radiant graph view): `knowledge.graph.get()`. */
+  graph;
+  constructor(client) {
+    this.nodes = new NodeServiceImpl(client);
+    this.links = new LinkServiceImpl(client);
+    this.recordLinks = new RecordLinkServiceImpl(client);
+    this.labels = new LabelServiceImpl(client);
+    this.graph = new GraphServiceImpl(client);
+  }
+};
+
+// src/storage/files.ts
+var FILES_BASE_PATH = "/storage/v1/files";
+var FileServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async upload(file, options) {
+    const metadata = {
+      name: options?.name ?? file.name,
+      content_type: options?.contentType ?? file.type ?? "application/octet-stream"
+    };
+    const formData = new FormData();
+    formData.append("metadata", new Blob([JSON.stringify(metadata)], { type: "application/json" }));
+    formData.append("file", file, metadata.name);
+    const response = await this.client.requestMultipart(
+      "POST",
+      FILES_BASE_PATH,
+      formData
+    );
+    return response.data;
+  }
+  async create(metadata) {
+    const formData = new FormData();
+    formData.append(
+      "metadata",
+      new Blob(
+        [
+          JSON.stringify({
+            name: metadata.name,
+            content_type: metadata.content_type ?? "application/octet-stream"
+          })
+        ],
+        { type: "application/json" }
+      )
+    );
+    const response = await this.client.requestMultipart(
+      "POST",
+      FILES_BASE_PATH,
+      formData
+    );
+    return response.data;
+  }
+  async createUploadUrl(id) {
+    const response = await this.client.request(
+      "POST",
+      `${FILES_BASE_PATH}/${id}/generate-upload-url`
+    );
+    return response.data;
+  }
+  async parse(id, options) {
+    const response = await this.client.request(
+      "POST",
+      `${FILES_BASE_PATH}/${id}/parse`,
+      options ?? {}
+    );
+    return response.data;
+  }
+  async getContent(id) {
+    const response = await this.client.request(
+      "GET",
+      `${FILES_BASE_PATH}/${id}/content`
+    );
+    return response.data;
+  }
+  async get(id) {
+    const response = await this.client.request(
+      "GET",
+      `${FILES_BASE_PATH}/${id}`
+    );
+    return response.data;
+  }
+  async createDownloadUrl(id, options) {
+    const body = options?.allowsMultiUse !== void 0 ? { allows_multi_use: options.allowsMultiUse } : void 0;
+    const response = await this.client.request(
+      "POST",
+      `${FILES_BASE_PATH}/${id}/generate-download-url`,
+      body
+    );
+    return response.data;
+  }
+  async download(id) {
+    const { response } = await this.client.requestRaw("GET", `${FILES_BASE_PATH}/${id}/download`);
+    return await response.blob();
+  }
+};
+
+// src/storage/index.ts
+var StorageClient = class {
+  files;
+  constructor(client) {
+    this.files = new FileServiceImpl(client);
+  }
+};
+
+// src/workflow/executions.ts
+var EXECUTIONS_BASE_PATH = "/workflows/v1/executions";
+var WORKFLOWS_BASE_PATH = "/workflows/v1/workflows";
+var ExecutionServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      EXECUTIONS_BASE_PATH,
+      options
+    );
+  }
+  async get(id) {
+    return this.client.request("GET", `${EXECUTIONS_BASE_PATH}/${id}`);
+  }
+  async getDetail(id) {
+    return this.client.request(
+      "GET",
+      `${EXECUTIONS_BASE_PATH}/${id}/detail`
+    );
+  }
+  async getNodeItems(executionId, nodeId, runIndex, options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${EXECUTIONS_BASE_PATH}/${executionId}/nodes/${nodeId}/runs/${runIndex}/items`,
+      options
+    );
+  }
+  async listForWorkflow(key, options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${WORKFLOWS_BASE_PATH}/${key}/executions`,
+      options
+    );
+  }
+};
+
+// src/workflow/node-types.ts
+var NODE_TYPES_BASE_PATH = "/workflows/v1/node-types";
+var NodeTypeServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list() {
+    const response = await this.client.request("GET", NODE_TYPES_BASE_PATH);
+    return response.data;
+  }
+  async invokeMethod(type, method, request = {}) {
+    const path = `${NODE_TYPES_BASE_PATH}/${encodeURIComponent(type)}/methods/${encodeURIComponent(method)}`;
+    return this.client.request("POST", path, request);
+  }
+};
+
+// src/workflow/workflows.ts
+var WORKFLOWS_BASE_PATH2 = "/workflows/v1/workflows";
+var WorkflowServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", WORKFLOWS_BASE_PATH2, options);
+  }
+  async get(key) {
+    return this.client.request("GET", `${WORKFLOWS_BASE_PATH2}/${key}`);
+  }
+  async create(request) {
+    return this.client.request("POST", WORKFLOWS_BASE_PATH2, request);
+  }
+  async update(key, request) {
+    return this.client.request("PATCH", `${WORKFLOWS_BASE_PATH2}/${key}`, request);
+  }
+  async delete(key) {
+    await this.client.request("DELETE", `${WORKFLOWS_BASE_PATH2}/${key}`);
+  }
+  async run(key, request = {}) {
+    return this.client.request(
+      "POST",
+      `${WORKFLOWS_BASE_PATH2}/${key}/run`,
+      request
+    );
+  }
+  async testNode(key, nodeId, request) {
+    return this.client.request(
+      "POST",
+      `${WORKFLOWS_BASE_PATH2}/${key}/nodes/${nodeId}/test`,
+      request
+    );
+  }
+  async pause(key) {
+    return this.client.request("POST", `${WORKFLOWS_BASE_PATH2}/${key}/pause`, {});
+  }
+  async unpause(key) {
+    return this.client.request("POST", `${WORKFLOWS_BASE_PATH2}/${key}/unpause`, {});
+  }
+  listVersions(key, options = {}) {
+    return new chunk7RGN4E22_cjs.PageIterator((opts) => this.listVersionsPage(key, opts), options);
+  }
+  async listVersionsPage(key, options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      `${WORKFLOWS_BASE_PATH2}/${key}/versions`,
+      options
+    );
+  }
+  async getVersion(key, version) {
+    return this.client.request(
+      "GET",
+      `${WORKFLOWS_BASE_PATH2}/${key}/versions/${version}`
+    );
+  }
+  async restoreVersion(key, version) {
+    return this.client.request(
+      "POST",
+      `${WORKFLOWS_BASE_PATH2}/${key}/versions/${version}/restore`,
+      {}
+    );
+  }
+};
+
+// src/workflow/types.ts
+var DEFAULT_PORT = "main";
+var ERROR_PORT = "error";
+
+// src/workflow/index.ts
+var WorkflowClient = class {
+  /** Service for managing workflow definitions. */
+  workflows;
+  /** Service for reading workflow executions. */
+  executions;
+  /** Service for the node-type catalog + dynamic node methods. */
+  nodeTypes;
+  constructor(client) {
+    this.workflows = new WorkflowServiceImpl(client);
+    this.executions = new ExecutionServiceImpl(client);
+    this.nodeTypes = new NodeTypeServiceImpl(client);
+  }
+};
+
+Object.defineProperty(exports, "AppSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.AppSchema; }
+});
+Object.defineProperty(exports, "AttributeSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.AttributeSchema; }
+});
+Object.defineProperty(exports, "AuditFieldsSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.AuditFieldsSchema; }
+});
+Object.defineProperty(exports, "ColumnSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.ColumnSchema; }
+});
+Object.defineProperty(exports, "ComponentSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.ComponentSchema; }
+});
+Object.defineProperty(exports, "CurrencyAttributeMetaSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.CurrencyAttributeMetaSchema; }
+});
+Object.defineProperty(exports, "DEFAULT_PAGE_SIZE", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.DEFAULT_PAGE_SIZE; }
+});
+Object.defineProperty(exports, "DONE", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.DONE; }
+});
+Object.defineProperty(exports, "EntitySchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.EntitySchema; }
+});
+Object.defineProperty(exports, "EntityWithSchemaSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.EntityWithSchemaSchema; }
+});
+Object.defineProperty(exports, "FileRefSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.FileRefSchema; }
+});
+Object.defineProperty(exports, "FilterElementSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.FilterElementSchema; }
+});
+Object.defineProperty(exports, "FilterGroupSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.FilterGroupSchema; }
+});
+Object.defineProperty(exports, "ListSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.ListSchema; }
+});
+Object.defineProperty(exports, "ListViewSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.ListViewSchema; }
+});
+Object.defineProperty(exports, "MenuConfigurationSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.MenuConfigurationSchema; }
+});
+Object.defineProperty(exports, "MenuItemSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.MenuItemSchema; }
+});
+Object.defineProperty(exports, "MenuItemType", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.MenuItemType; }
+});
+Object.defineProperty(exports, "MetaClient", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.MetaClient; }
+});
+Object.defineProperty(exports, "ModuleSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.ModuleSchema; }
+});
+Object.defineProperty(exports, "OnDeleteActionSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.OnDeleteActionSchema; }
+});
+Object.defineProperty(exports, "PLATFORM_ATTRIBUTE_NAMES", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.PLATFORM_ATTRIBUTE_NAMES; }
+});
+Object.defineProperty(exports, "PLATFORM_USER_ID", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.PLATFORM_USER_ID; }
+});
+Object.defineProperty(exports, "PageActionSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.PageActionSchema; }
+});
+Object.defineProperty(exports, "PageIterator", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.PageIterator; }
+});
+Object.defineProperty(exports, "PageLayoutSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.PageLayoutSchema; }
+});
+Object.defineProperty(exports, "PageSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.PageSchema; }
+});
+Object.defineProperty(exports, "RelationAttributeMetaSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.RelationAttributeMetaSchema; }
+});
+Object.defineProperty(exports, "ResponseMetaSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.ResponseMetaSchema; }
+});
+Object.defineProperty(exports, "SortConfigSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.SortConfigSchema; }
+});
+Object.defineProperty(exports, "UserRefSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.UserRefSchema; }
+});
+Object.defineProperty(exports, "VariableSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.VariableSchema; }
+});
+Object.defineProperty(exports, "allCurrencyCodes", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.allCurrencyCodes; }
+});
+Object.defineProperty(exports, "createIterator", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.createIterator; }
+});
+Object.defineProperty(exports, "createListResultSchema", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.createListResultSchema; }
+});
+Object.defineProperty(exports, "currencyLabel", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.currencyLabel; }
+});
+Object.defineProperty(exports, "currencySymbol", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.currencySymbol; }
+});
+Object.defineProperty(exports, "currencySymbolSide", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.currencySymbolSide; }
+});
+Object.defineProperty(exports, "formatAmount", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.formatAmount; }
+});
+Object.defineProperty(exports, "formatMoney", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.formatMoney; }
+});
+Object.defineProperty(exports, "isPlatformAttributeName", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.isPlatformAttributeName; }
+});
+Object.defineProperty(exports, "localeNumberSeparators", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.localeNumberSeparators; }
+});
+Object.defineProperty(exports, "parseAmount", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.parseAmount; }
+});
+Object.defineProperty(exports, "parseCurrencyMeta", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.parseCurrencyMeta; }
+});
+Object.defineProperty(exports, "parseFileMeta", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.parseFileMeta; }
+});
+Object.defineProperty(exports, "parseRelationMeta", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.parseRelationMeta; }
+});
+Object.defineProperty(exports, "platformAttributes", {
+  enumerable: true,
+  get: function () { return chunk7RGN4E22_cjs.platformAttributes; }
+});
+exports.AccountClient = AccountClient;
+exports.ActionSchema = ActionSchema;
+exports.ActionScopeSchema = ActionScopeSchema;
+exports.AgentClient = AgentClient;
+exports.BatchTransactionErrorSchema = BatchTransactionErrorSchema;
+exports.BatchUpsertRecordsResponseSchema = BatchUpsertRecordsResponseSchema;
+exports.BatchUpsertTransactionResultSchema = BatchUpsertTransactionResultSchema;
+exports.BatchUpsertTransactionSchema = BatchUpsertTransactionSchema;
+exports.ConnectorClient = ConnectorClient;
+exports.ConversationClient = ConversationClient;
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.DEFAULT_PORT = DEFAULT_PORT;
+exports.DataClient = DataClient;
+exports.ERROR_PORT = ERROR_PORT;
+exports.ErrorCode = ErrorCode;
+exports.EventsClient = EventsClient;
+exports.FunctionsClient = FunctionsClient;
+exports.KnowledgeClient = KnowledgeClient;
+exports.KnowledgeLabelSchema = KnowledgeLabelSchema;
+exports.KnowledgeLinkSchema = KnowledgeLinkSchema;
+exports.KnowledgeNodeLabelSchema = KnowledgeNodeLabelSchema;
+exports.KnowledgeNodeMetadataSchema = KnowledgeNodeMetadataSchema;
+exports.KnowledgeNodeSchema = KnowledgeNodeSchema;
+exports.KnowledgeNodeSearchResultSchema = KnowledgeNodeSearchResultSchema;
+exports.KnowledgeRecordLinkSchema = KnowledgeRecordLinkSchema;
+exports.NodeNeighborhoodSchema = NodeNeighborhoodSchema;
+exports.OrganizationSchema = OrganizationSchema;
+exports.PLATFORM_ENTITIES = PLATFORM_ENTITIES;
+exports.PLATFORM_ENTITY_SLUGS = PLATFORM_ENTITY_SLUGS;
+exports.ProteosClient = ProteosClient;
+exports.ProteosError = ProteosError;
+exports.RoleEntityPermissionSchema = RoleEntityPermissionSchema;
+exports.RoleSchema = RoleSchema;
+exports.StorageClient = StorageClient;
+exports.UserRoleAssignmentSchema = UserRoleAssignmentSchema;
+exports.UserSchema = UserSchema;
+exports.WorkflowClient = WorkflowClient;
+exports.buildUrl = buildUrl;
+exports.getDefaultErrorCode = getDefaultErrorCode;
+exports.isBadRequest = isBadRequest;
+exports.isConflict = isConflict;
+exports.isForbidden = isForbidden;
+exports.isNotFound = isNotFound;
+exports.isPlatformEntity = isPlatformEntity;
+exports.isProteosError = isProteosError;
+exports.isUnauthorized = isUnauthorized;
+exports.parseErrorResponse = parseErrorResponse;
+exports.resolveOptions = resolveOptions;
+exports.toQueryParams = toQueryParams;
+exports.toQueryString = toQueryString;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map