aegis-platform-sdk 0.1.0 → 1.3.0

package/dist/cli.js

@@ -0,0 +1,3830 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { writeFile } from "fs/promises";
+
+// src/errors.ts
+var AegisAPIError = class extends Error {
+  statusCode;
+  detail;
+  payload;
+  constructor(statusCode, detail = "", payload = null) {
+    super(`HTTP ${statusCode}: ${detail}`);
+    this.name = new.target.name;
+    this.statusCode = statusCode;
+    this.detail = detail;
+    this.payload = payload;
+  }
+};
+var AuthError = class extends AegisAPIError {
+};
+var PermissionDeniedError = class extends AegisAPIError {
+};
+var NotFoundError = class extends AegisAPIError {
+};
+
+// src/transport.ts
+function buildUrl(baseUrl, path, params) {
+  const raw = baseUrl.replace(/\/+$/, "") + path;
+  let url;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
+    url = new URL(raw);
+  } else {
+    const origin = globalThis.location?.origin;
+    if (!origin) {
+      throw new Error(
+        `relative baseUrl "${baseUrl}" requires a browser origin \u2014 use an absolute URL in Node`
+      );
+    }
+    url = new URL(raw, origin);
+  }
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) url.searchParams.append(key, String(item));
+      } else {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+async function handleResponse(res) {
+  if (res.status === 204) return null;
+  const text = await res.text();
+  let payload = text;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  if (res.ok) return payload;
+  let detail = "";
+  if (payload && typeof payload === "object" && "detail" in payload) {
+    detail = String(payload.detail ?? "");
+  } else if (typeof payload === "string") {
+    detail = payload;
+  }
+  if (res.status === 401) throw new AuthError(401, detail || "unauthenticated", payload);
+  if (res.status === 403) throw new PermissionDeniedError(403, detail || "forbidden", payload);
+  if (res.status === 404) throw new NotFoundError(404, detail || "not found", payload);
+  throw new AegisAPIError(res.status, detail || text, payload);
+}
+
+// src/sse.ts
+async function* parseSseStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let event = "";
+  let data = [];
+  let id;
+  let retry;
+  const flush = () => {
+    if (data.length === 0) {
+      event = "";
+      return null;
+    }
+    const ev = { event: event || "message", data: data.join("\n") };
+    if (id !== void 0) ev.id = id;
+    if (retry !== void 0) ev.retry = retry;
+    event = "";
+    data = [];
+    return ev;
+  };
+  const handleLine = (line) => {
+    if (line === "") return flush();
+    if (line.startsWith(":")) return null;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "event":
+        event = value;
+        break;
+      case "data":
+        data.push(value);
+        break;
+      case "id":
+        id = value;
+        break;
+      case "retry": {
+        const n = Number(value);
+        if (Number.isFinite(n)) retry = n;
+        break;
+      }
+    }
+    return null;
+  };
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newline;
+      while ((newline = buffer.search(/\r\n|\n|\r/)) !== -1) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + (buffer[newline] === "\r" && buffer[newline + 1] === "\n" ? 2 : 1));
+        const ev = handleLine(line);
+        if (ev) yield ev;
+      }
+    }
+    if (buffer) handleLine(buffer);
+    const tail = flush();
+    if (tail) yield tail;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(t, attach) {
+    this.t = t;
+    this.attach = attach;
+  }
+  t;
+  attach;
+  async login(username, password, opts = {}) {
+    const body = { username, password };
+    if (opts.totpCode) body.totp_code = opts.totpCode;
+    const pair = await this.t.request("POST", "/auth/login", { json: body });
+    if (opts.attach !== false) this.attach(pair);
+    return pair;
+  }
+  /** Rotate a refresh token explicitly (`POST /auth/refresh`). The client
+   *  already does this transparently on 401 — call this only for manual
+   *  flows. Attaches the new pair unless `attach: false`. */
+  async refresh(refreshToken, opts = {}) {
+    const pair = await this.t.request("POST", "/auth/refresh", {
+      json: { refresh_token: refreshToken }
+    });
+    if (opts.attach !== false) this.attach(pair);
+    return pair;
+  }
+  me() {
+    return this.t.request("GET", "/auth/me");
+  }
+  /** Activate a vendor dev-mode session; requires the `vendor` role. */
+  enableDevMode(password) {
+    return this.t.request("POST", "/me/dev-mode", { json: { password } });
+  }
+};
+
+// src/resources/iam.ts
+var UsersResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/iam/users");
+  }
+  get(userId) {
+    return this.t.request("GET", `/iam/users/${userId}`);
+  }
+};
+var RolesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/iam/roles");
+  }
+  get(roleId) {
+    return this.t.request("GET", `/iam/roles/${roleId}`);
+  }
+};
+var GroupsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/iam/groups", { params: opts });
+  }
+  get(groupId) {
+    return this.t.request("GET", `/iam/groups/${groupId}`);
+  }
+  create(name, description) {
+    return this.t.request("POST", "/iam/groups", { json: { name, description } });
+  }
+  update(groupId, patch) {
+    return this.t.request("PATCH", `/iam/groups/${groupId}`, { json: patch });
+  }
+  delete(groupId) {
+    return this.t.request("DELETE", `/iam/groups/${groupId}`);
+  }
+  listMembers(groupId) {
+    return this.t.request("GET", `/iam/groups/${groupId}/members`);
+  }
+  addMember(groupId, userId) {
+    return this.t.request("POST", `/iam/groups/${groupId}/members`, { json: { user_id: userId } });
+  }
+  removeMember(groupId, userId) {
+    return this.t.request("DELETE", `/iam/groups/${groupId}/members/${userId}`);
+  }
+  listForUser(userId) {
+    return this.t.request("GET", `/iam/users/${userId}/groups`);
+  }
+};
+var PermissionsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(resource) {
+    return this.t.request("GET", "/iam/permissions", { params: { resource } });
+  }
+};
+var NavResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  tree(asRoleId) {
+    return this.t.request("GET", "/iam/nav", { params: { as_role_id: asRoleId } });
+  }
+};
+var IamResource = class {
+  users;
+  roles;
+  groups;
+  permissions;
+  nav;
+  constructor(t) {
+    this.users = new UsersResource(t);
+    this.roles = new RolesResource(t);
+    this.groups = new GroupsResource(t);
+    this.permissions = new PermissionsResource(t);
+    this.nav = new NavResource(t);
+  }
+};
+
+// src/resources/osdk.ts
+var OsdkResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/governance/tokens");
+  }
+  get(tokenId) {
+    return this.t.request("GET", `/governance/tokens/${tokenId}`);
+  }
+  /** Returns the plaintext secret ONCE — stash it like any other secret. */
+  create(name, scopes, expiresAt) {
+    return this.t.request("POST", "/governance/tokens", {
+      json: { name, scopes, expires_at: expiresAt }
+    });
+  }
+  rotate(tokenId) {
+    return this.t.request("POST", `/governance/tokens/${tokenId}/rotate`);
+  }
+  revoke(tokenId) {
+    return this.t.request("DELETE", `/governance/tokens/${tokenId}`);
+  }
+};
+
+// src/resources/operator.ts
+var OperatorTasksResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/operator/tasks", { params: { ...opts } });
+  }
+  get(taskId) {
+    return this.t.request("GET", `/operator/tasks/${taskId}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/operator/tasks", { json: input });
+  }
+  cancel(taskId) {
+    return this.t.request("PATCH", `/operator/tasks/${taskId}`, { json: { action: "cancel" } });
+  }
+  retry(taskId) {
+    return this.t.request("PATCH", `/operator/tasks/${taskId}`, { json: { action: "retry" } });
+  }
+  reprioritize(taskId, priority) {
+    return this.t.request("PATCH", `/operator/tasks/${taskId}`, {
+      json: { action: "reprioritize", priority }
+    });
+  }
+};
+var OperatorResource = class {
+  tasks;
+  constructor(t) {
+    this.tasks = new OperatorTasksResource(t);
+  }
+};
+
+// src/resources/ontology.ts
+var ObjectsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  get(objectId) {
+    return this.t.request("GET", `/ontology/nodes/${objectId}`);
+  }
+  list(kind, opts = {}) {
+    return this.t.request("GET", "/ontology/nodes", { params: { node_type: kind, ...opts } });
+  }
+  create(kind, properties, name) {
+    return this.t.request("POST", "/ontology/nodes", {
+      json: { kind, properties, name }
+    });
+  }
+  createMany(kind, items, markings) {
+    return this.t.request("POST", "/ontology/nodes/bulk", { json: { kind, items, markings } });
+  }
+  delete(objectId) {
+    return this.t.request("DELETE", `/ontology/nodes/${objectId}`);
+  }
+  bulkDelete(opts) {
+    return this.t.request("POST", "/ontology/nodes/bulk-delete", { json: opts });
+  }
+  links(objectId) {
+    return this.t.request("GET", `/entities/${objectId}/links`);
+  }
+  history(objectId) {
+    return this.t.request("GET", `/lineage/by-asset/${objectId}`);
+  }
+  queryTimeseries(objectId, propertyName, opts = {}) {
+    return this.t.request(
+      "POST",
+      `/ontology/nodes/${objectId}/properties/${propertyName}/timeseries-query`,
+      { json: opts }
+    );
+  }
+  appendTimeseries(objectId, propertyName, points) {
+    return this.t.request(
+      "POST",
+      `/ontology/nodes/${objectId}/properties/${propertyName}/timeseries/append`,
+      { json: { points } }
+    );
+  }
+};
+var GraphResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  expand(seedId, opts = {}) {
+    return this.t.request("GET", `/entities/${seedId}/graph`, { params: opts });
+  }
+};
+var ExplorerResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  histogram(property, filters) {
+    return this.t.request("GET", "/entities/aggregate", {
+      params: { property, ...filters }
+    });
+  }
+  timeline(filters, bin) {
+    return this.t.request("GET", "/entities/timeline", {
+      params: { bin, ...filters }
+    });
+  }
+};
+var ObjectTypesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  get(kind) {
+    return this.t.request("GET", `/ontology/object-types/${kind}`);
+  }
+  create(kind, input) {
+    return this.t.request("POST", "/ontology/object-types", { json: { kind, ...input } });
+  }
+  update(kind, input) {
+    return this.t.request("PUT", `/ontology/object-types/${kind}`, { json: input });
+  }
+  delete(kind) {
+    return this.t.request("DELETE", `/ontology/object-types/${kind}`);
+  }
+};
+var LinkTypesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  declare(input) {
+    return this.t.request("POST", "/ontology/link-types", { json: input });
+  }
+  delete(edgeId) {
+    return this.t.request("DELETE", `/ontology/link-types/${edgeId}`);
+  }
+};
+var OntologyResource = class {
+  constructor(t) {
+    this.t = t;
+    this.objects = new ObjectsResource(t);
+    this.graph = new GraphResource(t);
+    this.explorer = new ExplorerResource(t);
+    this.objectTypes = new ObjectTypesResource(t);
+    this.linkTypes = new LinkTypesResource(t);
+  }
+  t;
+  objects;
+  graph;
+  explorer;
+  objectTypes;
+  linkTypes;
+  /** Shortcut — same as `objectTypes.get(kind)`. */
+  objectType(kind) {
+    return this.objectTypes.get(kind);
+  }
+  osdkManifest() {
+    return this.t.request("GET", "/ontology/osdk/manifest");
+  }
+  osdkFunctions() {
+    return this.t.request("GET", "/ontology/osdk/manifest/functions");
+  }
+  osdkGenerate(lang) {
+    return this.t.request("GET", "/ontology/osdk/generate", { params: { lang } });
+  }
+};
+
+// src/resources/aip.ts
+var FlowsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/campaign/flows");
+  }
+  get(flowId) {
+    return this.t.request("GET", `/campaign/flows/${flowId}`);
+  }
+  runs(flowId) {
+    return this.t.request("GET", `/campaign/flows/${flowId}/runs`);
+  }
+  patch(flowId, payload) {
+    return this.t.request("PATCH", `/campaign/flows/${flowId}`, { json: payload });
+  }
+  run(flowId, dryRun) {
+    return this.t.request("POST", `/campaign/flows/${flowId}/run`, {
+      json: dryRun === void 0 ? {} : { dry_run: dryRun }
+    });
+  }
+};
+var AgentsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/campaign/agents");
+  }
+  get(agentId) {
+    return this.t.request("GET", `/campaign/agents/${agentId}`);
+  }
+  patch(agentId, config) {
+    return this.t.request("PATCH", `/campaign/agents/${agentId}`, { json: config });
+  }
+  manualRun(agentId) {
+    return this.t.request("POST", `/campaign/agents/${agentId}/runs`);
+  }
+  runs(agentId) {
+    return this.t.request("GET", `/campaign/agents/${agentId}/runs`);
+  }
+};
+var ModelsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  catalog(provider) {
+    return this.t.request("GET", "/platform/v25/aip/models/catalog", { params: { provider } });
+  }
+  defaults() {
+    return this.t.request("GET", "/platform/v25/aip/models/defaults");
+  }
+  setDefault(input) {
+    return this.t.request("PUT", "/platform/v25/aip/models/defaults", { json: input });
+  }
+};
+var BudgetResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  get() {
+    return this.t.request("GET", "/platform/v23/llm-budget");
+  }
+  set(tokensPerMonth) {
+    return this.t.request("PUT", "/platform/v23/llm-budget", {
+      json: { tokens_per_month: tokensPerMonth }
+    });
+  }
+};
+var AipResource = class {
+  flows;
+  agents;
+  models;
+  budget;
+  constructor(t) {
+    this.flows = new FlowsResource(t);
+    this.agents = new AgentsResource(t);
+    this.models = new ModelsResource(t);
+    this.budget = new BudgetResource(t);
+  }
+};
+
+// src/resources/functions.ts
+var FunctionsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v26/functions");
+  }
+  get(slug) {
+    return this.t.request("GET", `/platform/v26/functions/${slug}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v26/functions", { json: input });
+  }
+  invoke(slug, inputs, opts = {}) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/invoke`, {
+      json: { inputs: inputs ?? {}, ...opts }
+    });
+  }
+  tests(slug) {
+    return this.t.request("GET", `/platform/v26/functions/${slug}/tests`);
+  }
+  addTest(slug, name, inputs, expectedContains) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/tests`, {
+      json: { name, inputs, expected_contains: expectedContains }
+    });
+  }
+  runTest(slug, testId) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/tests/${testId}/run`);
+  }
+  runTests(slug) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/test`);
+  }
+  publish(slug, branch) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/publish`, {
+      json: branch ? { branch } : {}
+    });
+  }
+  versions(slug) {
+    return this.t.request("GET", `/platform/v26/functions/${slug}/versions`);
+  }
+  pullRequests(slug, status) {
+    return this.t.request("GET", `/platform/v26/functions/${slug}/pull-requests`, {
+      params: { status }
+    });
+  }
+  openPullRequest(slug, input) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/pull-requests`, { json: input });
+  }
+  updatePullRequest(slug, prId, patch) {
+    return this.t.request("PATCH", `/platform/v26/functions/${slug}/pull-requests/${prId}`, {
+      json: patch
+    });
+  }
+  runPrCi(slug, prId) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/pull-requests/${prId}/ci`);
+  }
+  reviewPullRequest(slug, prId, decision, comment) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/pull-requests/${prId}/reviews`, {
+      json: { decision, comment }
+    });
+  }
+  mergePullRequest(slug, prId) {
+    return this.t.request("POST", `/platform/v26/functions/${slug}/pull-requests/${prId}/merge`);
+  }
+};
+var CodeRepositoriesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v26/code-repositories");
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v26/code-repositories", { json: input });
+  }
+  branches(repoId) {
+    return this.t.request("GET", `/platform/v26/code-repositories/${repoId}/branches`);
+  }
+  createBranch(repoId, name, description) {
+    return this.t.request("POST", `/platform/v26/code-repositories/${repoId}/branches`, {
+      json: { name, description }
+    });
+  }
+  functions(repoId) {
+    return this.t.request("GET", `/platform/v26/code-repositories/${repoId}/functions`);
+  }
+  assignFunction(repoId, slug) {
+    return this.t.request("POST", `/platform/v26/code-repositories/${repoId}/functions`, {
+      json: { slug }
+    });
+  }
+  runCi(repoId) {
+    return this.t.request("POST", `/platform/v26/code-repositories/${repoId}/ci`);
+  }
+  mergeBranch(repoId, sourceBranch, into) {
+    return this.t.request("POST", `/platform/v26/code-repositories/${repoId}/merge`, {
+      json: { source_branch: sourceBranch, into }
+    });
+  }
+};
+
+// src/resources/datasets.ts
+var DatasetsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/datasets");
+  }
+  get(name) {
+    return this.t.request("GET", `/datasets/${name}`);
+  }
+  sample(name, limit) {
+    return this.t.request("GET", `/datasets/${name}/sample`, { params: { limit } });
+  }
+  listBranches(name) {
+    return this.t.request("GET", `/datasets/${name}/branches`);
+  }
+  createBranch(name, branchName, opts = {}) {
+    return this.t.request("POST", `/datasets/${name}/branches`, {
+      json: { branch_name: branchName, ...opts }
+    });
+  }
+  deactivateBranch(name, branchName) {
+    return this.t.request("DELETE", `/datasets/${name}/branches/${branchName}`);
+  }
+  listTransactions(name, branch) {
+    return this.t.request("GET", `/datasets/${name}/transactions`, { params: { branch } });
+  }
+  beginTransaction(name, kind, branch) {
+    return this.t.request("POST", `/datasets/${name}/transactions`, { json: { kind, branch } });
+  }
+  commitTransaction(name, txId, inputPayload) {
+    return this.t.request("POST", `/datasets/${name}/transactions/${txId}/commit`, {
+      json: inputPayload
+    });
+  }
+  abortTransaction(name, txId, reason) {
+    return this.t.request("POST", `/datasets/${name}/transactions/${txId}/abort`, {
+      json: { reason }
+    });
+  }
+  mergeFastForward(name, source, into) {
+    return this.t.request("POST", `/datasets/${name}/branches/${source}/merge`, {
+      json: { into }
+    });
+  }
+  /** 409 responses carry the conflict body in `AegisAPIError.payload`. */
+  mergeThreeWay(name, source, into, resolutions) {
+    return this.t.request("POST", `/datasets/${name}/branches/${source}/merge3`, {
+      json: { into, resolutions }
+    });
+  }
+  getClassification(name) {
+    return this.t.request("GET", `/datasets/${name}/classification`);
+  }
+  setClassification(name, patch) {
+    return this.t.request("PATCH", `/datasets/${name}/classification`, { json: patch });
+  }
+  listMarkings(name) {
+    return this.t.request("GET", `/datasets/${name}/markings`);
+  }
+  applyMarking(name, markingId) {
+    return this.t.request("POST", `/datasets/${name}/markings`, { json: { marking_id: markingId } });
+  }
+  removeMarking(name, markingId) {
+    return this.t.request("DELETE", `/datasets/${name}/markings/${markingId}`);
+  }
+};
+
+// src/resources/reading.ts
+var GeoResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  nodes(opts = {}) {
+    return this.t.request("GET", "/api/v1/geo/nodes", { params: opts });
+  }
+  nodeTypes() {
+    return this.t.request("GET", "/api/v1/geo/node-types");
+  }
+  sources() {
+    return this.t.request("GET", "/api/v1/geo/sources");
+  }
+  edges(nodeIds, relationTypes) {
+    return this.t.request("GET", "/api/v1/geo/edges", {
+      params: { node_ids: nodeIds.join(","), relation_types: relationTypes?.join(",") }
+    });
+  }
+  /** Catalog of keyless reference layers (IBGE limits, CNES health, …). */
+  referenceLayers() {
+    return this.t.request("GET", "/api/v1/geo/reference-layers");
+  }
+  /** GeoJSON of one reference layer (resilient keyless proxy). */
+  referenceLayer(layerId, opts = {}) {
+    return this.t.request("GET", `/api/v1/geo/reference-layers/${encodeURIComponent(layerId)}`, {
+      params: opts
+    });
+  }
+  zones() {
+    return this.t.request("GET", "/api/v1/geo/zones");
+  }
+  importZones(features, opts = {}) {
+    return this.t.request("POST", "/api/v1/geo/zones/import", { json: { features, ...opts } });
+  }
+  deleteZone(zoneId) {
+    return this.t.request("DELETE", `/api/v1/geo/zones/${zoneId}`);
+  }
+  // ── Reference Layer Builder (the AEGIS "My Maps") ──────────────────────
+  //
+  // Each layer is one editable dataset + one DAG board + one dedicated
+  // node_type. Publishing runs the board; the materialized nodes show up on
+  // their own under the map's "Reference layers" tab.
+  // Read: `security.geo.view`; write: `security.geo.camada.manage`.
+  /** Builder layers of the tenant, grouped by "map" (the project). */
+  layers() {
+    return this.t.request("GET", "/api/v1/geo/layers");
+  }
+  /** Creates a layer (empty inline dataset + published board). The
+   *  `node_type` derives from the name and is IMMUTABLE. */
+  createLayer(input) {
+    return this.t.request("POST", "/api/v1/geo/layers", { json: input });
+  }
+  layerFeatures(boardId) {
+    return this.t.request("GET", `/api/v1/geo/layers/${boardId}/features`);
+  }
+  /** Saves the drawing as a versioned SNAPSHOT. `geometry` is GeoJSON
+   *  `[lng,lat]`; `geo_style` travels PER FEATURE (colour/alpha/extrusion). */
+  saveLayerFeatures(boardId, rows) {
+    return this.t.request("PUT", `/api/v1/geo/layers/${boardId}/features`, {
+      json: { rows }
+    });
+  }
+  /** Runs the board and RECONCILES — a feature deleted in the builder leaves
+   *  the map (the engine is upsert-only). */
+  publishLayer(boardId) {
+    return this.t.request("POST", `/api/v1/geo/layers/${boardId}/publish`);
+  }
+  /** Renames / regroups. Never changes the `node_type`; `mapa: ""` ungroups. */
+  patchLayer(boardId, changes) {
+    return this.t.request("PATCH", `/api/v1/geo/layers/${boardId}`, { json: changes });
+  }
+  /** Deletes the whole layer: materialized nodes + dataset + board. */
+  deleteLayer(boardId) {
+    return this.t.request("DELETE", `/api/v1/geo/layers/${boardId}`);
+  }
+};
+var MapTemplatesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  async list() {
+    const payload = await this.t.request("GET", "/platform/v22/map-templates");
+    return payload.items ?? [];
+  }
+  get(templateId) {
+    return this.t.request("GET", `/platform/v22/map-templates/${templateId}`);
+  }
+  create(name, spec, description = "") {
+    return this.t.request("POST", "/platform/v22/map-templates", {
+      json: { name, spec, description }
+    });
+  }
+  instantiate(templateId, variables) {
+    return this.t.request("POST", `/platform/v22/map-templates/${templateId}/instantiate`, {
+      json: { variables: variables ?? {} }
+    });
+  }
+  /** Returns the raw SVG markup (non-JSON body). */
+  exportSvg(templateId) {
+    return this.t.request("GET", `/platform/v22/map-templates/${templateId}/export.svg`);
+  }
+};
+var MediaResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  listSets() {
+    return this.t.request("GET", "/platform/v23/media/sets");
+  }
+  createSet(input) {
+    return this.t.request("POST", "/platform/v23/media/sets", { json: input });
+  }
+  deleteSet(setId) {
+    return this.t.request("DELETE", `/platform/v23/media/sets/${setId}`);
+  }
+  listItems(setId) {
+    return this.t.request("GET", `/platform/v23/media/sets/${setId}/items`);
+  }
+  /** Metadata only — no file bytes are uploaded (pass a pre-supplied `uri`). */
+  addItem(setId, input) {
+    return this.t.request("POST", `/platform/v23/media/sets/${setId}/items`, { json: input });
+  }
+};
+var DocsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  tree() {
+    return this.t.request("GET", "/docs/tree");
+  }
+  read(path) {
+    return this.t.request("GET", "/docs/content", { params: { path } });
+  }
+};
+var PagesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/platform/v23/pages", { params: opts });
+  }
+  get(slug) {
+    return this.t.request("GET", `/platform/v23/pages/${slug}`);
+  }
+  getConfig(slug) {
+    return this.t.request("GET", `/platform/v23/pages/${slug}/config`);
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/pages", { json: input });
+  }
+  update(slug, patch) {
+    return this.t.request("PATCH", `/platform/v23/pages/${slug}`, { json: patch });
+  }
+  /** Soft delete — page moves to status=archived. */
+  delete(slug) {
+    return this.t.request("DELETE", `/platform/v23/pages/${slug}`);
+  }
+  duplicate(slug) {
+    return this.t.request("POST", `/platform/v23/pages/${slug}/duplicate`);
+  }
+  putConfig(slug, config) {
+    return this.t.request("PUT", `/platform/v23/pages/${slug}/config`, { json: { config } });
+  }
+  publish(slug) {
+    return this.t.request("POST", `/platform/v23/pages/${slug}/publish`);
+  }
+};
+var DossierResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  startGeneric(nodeId, purpose) {
+    return this.t.request("POST", `/ontology/nodes/${nodeId}/dossier`, {
+      json: purpose ? { purpose } : {}
+    });
+  }
+  /** Requires `anchor_node_id` or `node_ids`. */
+  startComposite(input) {
+    if (!input.anchor_node_id && !input.node_ids?.length) {
+      throw new Error("startComposite requires anchor_node_id or node_ids");
+    }
+    return this.t.request("POST", "/ontology/dossier/composite", { json: input });
+  }
+  /** Poll until `status === "done"`; `result` is then populated. */
+  get(taskId) {
+    return this.t.request("GET", `/ontology/dossier/${taskId}`);
+  }
+};
+var TimeSeriesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v23/timeseries");
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/timeseries", { json: input });
+  }
+  delete(chartId) {
+    return this.t.request("DELETE", `/platform/v23/timeseries/${chartId}`);
+  }
+  render(chartId) {
+    return this.t.request("POST", `/platform/v23/timeseries/${chartId}/render`);
+  }
+};
+
+// src/resources/publicGuest.ts
+var PublicGuestResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  base(token) {
+    return `/public/v1/guest/${encodeURIComponent(token)}`;
+  }
+  /** Menu/resumo do token: label, subject, status, geo, ações permitidas. */
+  menu(token) {
+    return this.t.request("GET", this.base(token));
+  }
+  /** Reporta uma posição GPS; o backend avalia cerca/rota/destino. */
+  fix(token, body) {
+    return this.t.request("POST", `${this.base(token)}/fix`, { json: body });
+  }
+  /** Invoca uma ação permitida do token (ex.: abrir portão). */
+  invoke(token, actionId, input = {}) {
+    return this.t.request(
+      "POST",
+      `${this.base(token)}/actions/${encodeURIComponent(actionId)}`,
+      { json: { input } }
+    );
+  }
+  /**
+   * Onda 2 — última posição do VISITANTE amarrado a um token de MORADOR
+   * (`geo.live_ref`). Sem push: a SPA do morador faz polling desta rota. O
+   * morador só vê ESSA visita (least-privilege). Retorna `{available, lat,
+   * lng, ts, inside_fence, arrived, deviated, distance_to_target_m,
+   * visit_status}`; `available:false` enquanto o visitante não mandou fix.
+   */
+  position(token) {
+    return this.t.request("GET", `${this.base(token)}/position`);
+  }
+  /** Documento vinculado ao token (se `geo.document_id`). */
+  document(token) {
+    return this.t.request("GET", `${this.base(token)}/document`);
+  }
+  /** Consulta um object-set embutido no documento do token. */
+  queryObjectSet(token, body) {
+    return this.t.request(
+      "POST",
+      `${this.base(token)}/document/object-sets/query`,
+      { json: body }
+    );
+  }
+  /** Um nó da ontologia referenciado pelo documento (mascarado por ABAC). */
+  documentNode(token, nodeId) {
+    return this.t.request("GET", `${this.base(token)}/document/node`, {
+      params: { node_id: nodeId }
+    });
+  }
+  /** Descritor da Page vinculada ao token (`geo.page_slug`). */
+  page(token, slug) {
+    return this.t.request("GET", `${this.base(token)}/pages/${encodeURIComponent(slug)}`);
+  }
+  /** Avalia as variáveis da Page (com overrides só de variáveis estáticas). */
+  evaluatePage(token, slug, overrides = {}) {
+    return this.t.request(
+      "POST",
+      `${this.base(token)}/pages/${encodeURIComponent(slug)}/evaluate`,
+      { json: { overrides } }
+    );
+  }
+  /**
+   * URL absoluta de um objeto de mídia do documento (bytes servidos com
+   * `Cache-Control: private`). Retorna string p/ `<img src>`/`<a href>` —
+   * NÃO faz request (o transporte é JSON-cêntrico). A `key` deve começar
+   * com `notepad/{doc_id}/` (validado no backend).
+   */
+  mediaUrl(token, key) {
+    return buildUrl(this.t.baseUrl, `${this.base(token)}/media`, { key });
+  }
+};
+
+// src/resources/operational.ts
+var AlertFeedsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/alerts/feeds");
+  }
+  create(name, filters, cadenceSeconds = 300) {
+    return this.t.request("POST", "/alerts/feeds", {
+      json: { name, filters, cadence_seconds: cadenceSeconds }
+    });
+  }
+  delete(feedId) {
+    return this.t.request("DELETE", `/alerts/feeds/${feedId}`);
+  }
+  alerts() {
+    return this.t.request("GET", "/alerts/feeds/alerts");
+  }
+  acknowledge(alertId) {
+    return this.t.request("POST", `/alerts/feeds/${alertId}/acknowledge`);
+  }
+};
+var AlertWatchesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/alerts/watches");
+  }
+  create(objectId) {
+    return this.t.request("POST", "/alerts/watches", { json: { object_id: objectId } });
+  }
+  delete(watchId) {
+    return this.t.request("DELETE", `/alerts/watches/${watchId}`);
+  }
+  alerts() {
+    return this.t.request("GET", "/alerts/watches/alerts");
+  }
+  acknowledge(alertId) {
+    return this.t.request("POST", `/alerts/watches/${alertId}/acknowledge`);
+  }
+};
+var AlertGeofencesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/alerts/geofences");
+  }
+  /** `coordinates` is shape-dependent: polygon `[[lon,lat],…]`, circle
+   *  `{center, radius_meters}`, corridor/route `{waypoints, width_meters}`. */
+  create(input) {
+    return this.t.request("POST", "/alerts/geofences", { json: input });
+  }
+  update(geofenceId, patch) {
+    return this.t.request("PATCH", `/alerts/geofences/${geofenceId}`, { json: patch });
+  }
+  delete(geofenceId) {
+    return this.t.request("DELETE", `/alerts/geofences/${geofenceId}`);
+  }
+  alerts() {
+    return this.t.request("GET", "/alerts/geofences/alerts");
+  }
+  acknowledge(alertId) {
+    return this.t.request("POST", `/alerts/geofences/${alertId}/acknowledge`);
+  }
+};
+var AlertSharesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/alerts/shares");
+  }
+  acknowledge(alertId) {
+    return this.t.request("POST", `/alerts/shares/${alertId}/ack`);
+  }
+};
+var AlertRoutesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/alerts/routes");
+  }
+  create(input) {
+    return this.t.request("POST", "/alerts/routes", { json: input });
+  }
+  update(routeId, patch) {
+    return this.t.request("PATCH", `/alerts/routes/${routeId}`, { json: patch });
+  }
+  delete(routeId) {
+    return this.t.request("DELETE", `/alerts/routes/${routeId}`);
+  }
+  silence(routeId, minutes) {
+    return this.t.request("POST", `/alerts/routes/${routeId}/silence`, { json: { minutes } });
+  }
+  unsilence(routeId) {
+    return this.silence(routeId, 0);
+  }
+  silenceState(routeId) {
+    return this.t.request("GET", `/alerts/routes/${routeId}/silence`);
+  }
+  async kinds() {
+    const payload = await this.t.request("GET", "/alerts/routes/kinds");
+    return payload.kinds ?? [];
+  }
+};
+var AlertInboxResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/alerts/inbox", {
+      params: {
+        kinds: opts.kinds?.join(","),
+        severities: opts.severities?.join(","),
+        status: opts.status,
+        limit: opts.limit,
+        offset: opts.offset
+      }
+    });
+  }
+  async countPending() {
+    const payload = await this.t.request("GET", "/alerts/count_pending");
+    return payload.count ?? 0;
+  }
+  acknowledge(alertId) {
+    return this.t.request("POST", `/alerts/${alertId}/acknowledge`);
+  }
+};
+var AlertsResource = class {
+  constructor(t) {
+    this.t = t;
+    this.feeds = new AlertFeedsResource(t);
+    this.watches = new AlertWatchesResource(t);
+    this.geofences = new AlertGeofencesResource(t);
+    this.shares = new AlertSharesResource(t);
+    this.routes = new AlertRoutesResource(t);
+    this.inbox = new AlertInboxResource(t);
+  }
+  t;
+  feeds;
+  watches;
+  geofences;
+  shares;
+  routes;
+  inbox;
+  escalate(alertId) {
+    return this.t.request("POST", `/alerts/escalate/${alertId}`);
+  }
+  channels() {
+    return this.t.request("GET", "/alerts/channels");
+  }
+  /**
+   * `PUT /alerts/channels/{ref}` — point a delivery channel at its
+   * destination.
+   *
+   * Exists so this is a GESTURE: before it, sending alerts to the team's
+   * Discord (or any webhook) meant editing the tenant's JSONB in the
+   * database. Audited as `alert_channel.configured`.
+   *
+   * `ref` is the channel name (`"discord"`) or a named ref
+   * (`"discord-plantao"`, then pass `channel: "discord"`). Fields are open
+   * because the vocabulary belongs to the CHANNEL, not the core.
+   *
+   * The response returns the config MASKED — a webhook URL is the
+   * credential, and reads never hand it back whole.
+   * Perm: `alerts.routes.manage`.
+   */
+  setChannel(ref, config) {
+    return this.t.request("PUT", `/alerts/channels/${encodeURIComponent(ref)}`, {
+      json: config
+    });
+  }
+  /** `DELETE /alerts/channels/{ref}` — audited as `alert_channel.removed`. */
+  deleteChannel(ref) {
+    return this.t.request("DELETE", `/alerts/channels/${encodeURIComponent(ref)}`);
+  }
+};
+var AlarmsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v26/alarms");
+  }
+  /** `node_id` XOR `node_type`; operator ∈ gt|gte|lt|lte|eq|ne. */
+  create(input) {
+    return this.t.request("POST", "/platform/v26/alarms", { json: input });
+  }
+  update(ruleId, patch) {
+    return this.t.request("PUT", `/platform/v26/alarms/${encodeURIComponent(ruleId)}`, {
+      json: patch
+    });
+  }
+  delete(ruleId) {
+    return this.t.request("DELETE", `/platform/v26/alarms/${encodeURIComponent(ruleId)}`);
+  }
+  events(opts = {}) {
+    return this.t.request("GET", "/platform/v26/alarms/events", { params: opts });
+  }
+};
+var EventsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  pipelineStatus() {
+    return this.t.request("GET", "/api/v1/events/pipeline/status");
+  }
+  dlqList(limit = 50) {
+    return this.t.request("GET", "/api/v1/events/pipeline/dlq", { params: { limit } });
+  }
+  /** Exactly one of `ids` / `all` is required. */
+  dlqRetry(opts) {
+    assertIdsXorAll(opts);
+    return this.t.request("POST", "/api/v1/events/pipeline/dlq/retry", { json: opts });
+  }
+  /** Exactly one of `ids` / `all` is required. */
+  dlqPurge(opts) {
+    assertIdsXorAll(opts);
+    return this.t.request("POST", "/api/v1/events/pipeline/dlq/purge", { json: opts });
+  }
+};
+function assertIdsXorAll(opts) {
+  const hasIds = !!opts.ids?.length;
+  if (hasIds === !!opts.all) throw new Error("pass exactly one of ids or all");
+}
+var ConnectorsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/governance/agents");
+  }
+  patch(agentId, patch) {
+    const body = Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== void 0));
+    if (Object.keys(body).length === 0) throw new Error("empty patch");
+    return this.t.request("PATCH", `/governance/agents/${agentId}`, { json: body });
+  }
+  /** status ∈ inactive|active|running|degraded|failed */
+  setStatus(agentId, status) {
+    return this.patch(agentId, { status });
+  }
+  bindings(agentId) {
+    return this.t.request("GET", `/governance/agents/${agentId}/skills`);
+  }
+  /** Two calls: creates the worker agent, then binds the `connector.http` skill. */
+  async register(input) {
+    const agent = await this.t.request("POST", "/governance/agents", {
+      json: {
+        slug: input.slug,
+        display_name: input.display_name,
+        kind: "worker",
+        config: input.cron_preset ? { cron_preset: input.cron_preset } : {}
+      }
+    });
+    await this.t.request("POST", `/governance/agents/${agent.id}/skills`, {
+      json: {
+        skill_key: "connector.http",
+        config: {
+          base_url: input.base_url,
+          path: input.path ?? "",
+          node_type: input.node_type,
+          id_field: input.id_field,
+          name_field: input.name_field ?? "",
+          records_path: input.records_path ?? "",
+          auth: input.auth,
+          pagination: input.pagination
+        }
+      }
+    });
+    return agent;
+  }
+  test(agentId) {
+    return this.t.request("POST", `/governance/agents/${agentId}/skills/connector.http/test`);
+  }
+  run(agentId) {
+    return this.t.request("POST", `/governance/agents/${agentId}/run`, {
+      json: { skill_key: "connector.http" }
+    });
+  }
+  /**
+   * Start/renew QR pairing for a skill with the `pairing` capability (WhatsApp
+   * station). Pass `{ refresh: true }` to force a fresh code.
+   */
+  pairingStart(agentId, skillKey, opts = {}) {
+    const { target, ...json } = opts;
+    return this.t.request("POST", `/governance/agents/${agentId}/skills/${skillKey}/pairing`, {
+      json,
+      params: target ? { target } : void 0
+    });
+  }
+  /** Read-only poll of the pairing state (no side effects). `target` aims a pool number. */
+  pairingPoll(agentId, skillKey, opts = {}) {
+    return this.t.request("GET", `/governance/agents/${agentId}/skills/${skillKey}/pairing`, {
+      params: opts.target ? { target: opts.target } : void 0
+    });
+  }
+  /**
+   * Add / correct / remove a sub-unit administered by a connector that
+   * declares the `inventory` capability — e.g. one number of a WhatsApp
+   * number-station.
+   *
+   * Reading is NOT here: the inventory already reaches callers through the
+   * snapshot the tick publishes on the device mirror (`GET /api/v1/edge/nodes`
+   * → `nodes[].pool`). A second read path would drift between ticks.
+   */
+  applyInventory(agentId, skillKey, op, item) {
+    return this.t.request(
+      "POST",
+      `/governance/agents/${agentId}/skills/${skillKey}/inventory`,
+      { json: { op, item } }
+    );
+  }
+  schedulerTick() {
+    return this.t.request("POST", "/governance/agents/scheduler/tick");
+  }
+  /** source ∈ native|clawhub. Rows carry an additive `capabilities` field. */
+  skillCatalog(source) {
+    return this.t.request("GET", "/governance/agents/skills", { params: { source } });
+  }
+  installOpenclaw(slug) {
+    return this.t.request("POST", "/governance/agents/skills/openclaw/install", {
+      json: { slug: slug.replace(/^openclaw:/, "") }
+    });
+  }
+  refreshOpenclaw() {
+    return this.t.request("POST", "/governance/agents/skills/openclaw/refresh");
+  }
+};
+var PipelinesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v22/pipelines");
+  }
+  transformPreview(sampleRows, steps) {
+    return this.t.request("POST", "/platform/v23/pipeline/transform/preview", {
+      json: { sample_rows: sampleRows, steps }
+    });
+  }
+  dryRun(boardId) {
+    return this.t.request("POST", `/platform/v23/pipeline/${boardId}/dry-run`);
+  }
+  syncPreview(format, opts = {}) {
+    const body = { format };
+    for (const [k, v] of Object.entries(opts)) if (v !== void 0) body[k] = v;
+    return this.t.request("POST", "/platform/v23/pipeline/sync/preview", { json: body });
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v22/pipelines", { json: input });
+  }
+  update(pipelineId, patch) {
+    return this.t.request("PUT", `/platform/v22/pipelines/${pipelineId}`, { json: patch });
+  }
+  setSchedule(pipelineId, preset) {
+    return this.update(pipelineId, { schedule_preset: preset || "" });
+  }
+  build(pipelineId, opts = {}) {
+    return this.t.request("POST", `/platform/v22/pipelines/${pipelineId}/build`, {
+      params: {
+        incremental: String(opts.incremental ?? false),
+        branch: opts.branch ?? "main"
+      }
+    });
+  }
+  runs(pipelineId, limit = 50) {
+    return this.t.request("GET", `/platform/v22/pipelines/${pipelineId}/runs`, {
+      params: { limit }
+    });
+  }
+};
+var ChatChannelsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/chat/channels");
+  }
+  get(channelId) {
+    return this.t.request("GET", `/chat/channels/${channelId}`);
+  }
+  create(input) {
+    const body = Object.fromEntries(Object.entries(input).filter(([, v]) => v !== void 0));
+    return this.t.request("POST", "/chat/channels", { json: body });
+  }
+  patch(channelId, payload) {
+    return this.t.request("PATCH", `/chat/channels/${channelId}`, { json: payload });
+  }
+  delete(channelId) {
+    return this.t.request("DELETE", `/chat/channels/${channelId}`);
+  }
+};
+var ChatMessagesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(channelId, opts = {}) {
+    return this.t.request("GET", `/chat/channels/${channelId}/messages`, { params: opts });
+  }
+  send(channelId, body, opts = {}) {
+    return this.t.request("POST", `/chat/channels/${channelId}/messages`, {
+      json: { body, classification: opts.classification ?? "U", embeds: opts.embeds }
+    });
+  }
+};
+var ChatResource = class {
+  channels;
+  messages;
+  constructor(t) {
+    this.channels = new ChatChannelsResource(t);
+    this.messages = new ChatMessagesResource(t);
+  }
+};
+var NotepadResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v23/notepad");
+  }
+  get(docId) {
+    return this.t.request("GET", `/platform/v23/notepad/${encodeURIComponent(docId)}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/notepad", { json: input });
+  }
+  /** Mirrors Python: all keys are sent (null = unchanged server-side). */
+  update(docId, patch) {
+    return this.t.request("PUT", `/platform/v23/notepad/${encodeURIComponent(docId)}`, {
+      json: {
+        title: patch.title ?? null,
+        body_md: patch.body_md ?? null,
+        markings: patch.markings ?? null,
+        pinned: patch.pinned ?? null
+      }
+    });
+  }
+  delete(docId) {
+    return this.t.request("DELETE", `/platform/v23/notepad/${encodeURIComponent(docId)}`);
+  }
+};
+
+// src/resources/governance.ts
+var LineageResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  graph(opts = {}) {
+    return this.t.request("GET", "/platform/v23/lineage-graph", { params: opts });
+  }
+  events(opts = {}) {
+    return this.t.request("GET", "/lineage/events", { params: opts });
+  }
+};
+var AccessAuditResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/governance/access-audit", { params: opts });
+  }
+};
+var MarkingCategoriesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/markings/categories", { params: opts });
+  }
+  create(input) {
+    return this.t.request("POST", "/markings/categories", { json: input });
+  }
+};
+var MarkingsResource = class {
+  constructor(t) {
+    this.t = t;
+    this.categories = new MarkingCategoriesResource(t);
+  }
+  t;
+  categories;
+  list(opts = {}) {
+    return this.t.request("GET", "/markings", { params: opts });
+  }
+  get(markingId) {
+    return this.t.request("GET", `/markings/${markingId}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/markings", { json: input });
+  }
+  update(markingId, patch) {
+    return this.t.request("PATCH", `/markings/${markingId}`, { json: patch });
+  }
+  listEligibility(markingId) {
+    return this.t.request("GET", `/markings/${markingId}/eligibility`);
+  }
+  grantEligibility(markingId, userId, canApply = false) {
+    return this.t.request("POST", `/markings/${markingId}/eligibility`, {
+      json: { user_id: userId, can_apply: canApply }
+    });
+  }
+  revokeEligibility(markingId, userId) {
+    return this.t.request("DELETE", `/markings/${markingId}/eligibility/${userId}`);
+  }
+};
+var ResourceMarkingsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(resourceKind, resourceId) {
+    return this.t.request("GET", `/resources/${resourceKind}/${resourceId}/markings`);
+  }
+  apply(resourceKind, resourceId, markingId) {
+    return this.t.request("POST", `/resources/${resourceKind}/${resourceId}/markings`, {
+      json: { marking_id: markingId }
+    });
+  }
+  remove(resourceKind, resourceId, markingId) {
+    return this.t.request(
+      "DELETE",
+      `/resources/${resourceKind}/${resourceId}/markings/${markingId}`
+    );
+  }
+};
+var PropertyMarkingsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  listForNode(nodeId) {
+    return this.t.request("GET", `/ontology/nodes/${nodeId}/property-markings`);
+  }
+  listOne(nodeId, propertyKey) {
+    return this.t.request("GET", `/ontology/nodes/${nodeId}/properties/${propertyKey}/markings`);
+  }
+  apply(nodeId, propertyKey, markingId) {
+    return this.t.request("POST", `/ontology/nodes/${nodeId}/properties/${propertyKey}/markings`, {
+      json: { marking_id: markingId }
+    });
+  }
+  remove(nodeId, propertyKey, markingId) {
+    return this.t.request(
+      "DELETE",
+      `/ontology/nodes/${nodeId}/properties/${propertyKey}/markings/${markingId}`
+    );
+  }
+};
+var RowPoliciesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v26/row-policies");
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v26/row-policies", { json: input });
+  }
+  delete(policyId) {
+    return this.t.request("DELETE", `/platform/v26/row-policies/${encodeURIComponent(policyId)}`);
+  }
+};
+var ErasureResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  /** Dry-run: shows the match radius without mutating anything. */
+  preview(selector) {
+    return this.t.request("POST", "/governance/erasure/preview", { json: selector });
+  }
+  /** Requires `confirm: true`; pass `expected_count` to guard the radius (422 on mismatch). */
+  forget(selector, opts = {}) {
+    return this.t.request("POST", "/governance/erasure/forget", { json: { ...selector, ...opts } });
+  }
+};
+var RetentionResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/governance/retention");
+  }
+  set(target, retentionDays, active = true) {
+    return this.t.request("PUT", "/governance/retention", {
+      json: { target, retention_days: retentionDays, active }
+    });
+  }
+  delete(target) {
+    return this.t.request("DELETE", `/governance/retention/${encodeURIComponent(target)}`);
+  }
+  run(target) {
+    return this.t.request("POST", `/governance/retention/${encodeURIComponent(target)}/run`);
+  }
+};
+var GuestTokensResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v23/guest-tokens");
+  }
+  /** Plaintext token appears once in the response — treat as a secret. */
+  issue(input) {
+    return this.t.request("POST", "/platform/v23/guest-tokens", { json: input });
+  }
+  revoke(tokenId) {
+    return this.t.request("POST", `/platform/v23/guest-tokens/${tokenId}/revoke`);
+  }
+};
+
+// src/resources/platform.ts
+var WorkshopBriefingsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/workshop/apps", { params: { kind: "briefing" } });
+  }
+  get(briefingId) {
+    return this.t.request("GET", `/workshop/apps/${briefingId}`);
+  }
+  create(name) {
+    return this.t.request("POST", "/workshop/apps", { json: { name, kind: "briefing" } });
+  }
+  patch(briefingId, payload) {
+    return this.t.request("PATCH", `/workshop/apps/${briefingId}`, { json: payload });
+  }
+  broadcast(briefingId) {
+    return this.t.request("POST", `/workshop/briefings/${briefingId}/broadcast`);
+  }
+};
+var WorkshopDossiersResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/workshop/dossiers");
+  }
+  get(dossierId) {
+    return this.t.request("GET", `/workshop/dossiers/${dossierId}`);
+  }
+  create(title) {
+    return this.t.request("POST", "/workshop/dossiers", { json: { title } });
+  }
+  patch(dossierId, body) {
+    return this.t.request("PATCH", `/workshop/dossiers/${dossierId}`, { json: body });
+  }
+  delete(dossierId) {
+    return this.t.request("DELETE", `/workshop/dossiers/${dossierId}`);
+  }
+  addEmbed(dossierId, kind, sourceRef, nodeId) {
+    return this.t.request("POST", `/workshop/dossiers/${dossierId}/embeds`, {
+      json: { embed_kind: kind, source_ref: sourceRef, node_id: nodeId }
+    });
+  }
+  embeds(dossierId) {
+    return this.t.request("GET", `/workshop/dossiers/${dossierId}/embeds`);
+  }
+};
+var WorkshopCovsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(objectType) {
+    return this.t.request("GET", "/workshop/covs", { params: { object_type: objectType } });
+  }
+  get(covId) {
+    return this.t.request("GET", `/workshop/covs/${covId}`);
+  }
+  /** Full-object upsert. */
+  save(cov) {
+    return this.t.request("POST", "/workshop/covs", { json: cov });
+  }
+  delete(covId) {
+    return this.t.request("DELETE", `/workshop/covs/${covId}`);
+  }
+  setTeamDefault(covId) {
+    return this.t.request("POST", `/workshop/covs/${covId}/set-team-default`);
+  }
+};
+var WorkshopResource = class {
+  constructor(t) {
+    this.t = t;
+    this.briefings = new WorkshopBriefingsResource(t);
+    this.dossiers = new WorkshopDossiersResource(t);
+    this.covs = new WorkshopCovsResource(t);
+  }
+  t;
+  briefings;
+  dossiers;
+  covs;
+  widgetCatalog(proposableOnly = false) {
+    return this.t.request("GET", "/workshop/widget-catalog", {
+      params: proposableOnly ? { proposable_only: "true" } : {}
+    });
+  }
+};
+var ComputeProvidersResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  catalog() {
+    return this.t.request("GET", "/compute/providers/catalog");
+  }
+  list() {
+    return this.t.request("GET", "/compute/providers");
+  }
+  /** `api_key` is write-only — never returned by the API. */
+  create(input) {
+    return this.t.request("POST", "/compute/providers", { json: input });
+  }
+  update(providerId, patch) {
+    const body = Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== void 0));
+    return this.t.request("PUT", `/compute/providers/${providerId}`, { json: body });
+  }
+  delete(providerId) {
+    return this.t.request("DELETE", `/compute/providers/${providerId}`);
+  }
+  test(providerId) {
+    return this.t.request("POST", `/compute/providers/${providerId}/test`);
+  }
+};
+var ComputeReleasesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(name) {
+    return this.t.request("GET", "/compute/releases", { params: { name } });
+  }
+  publish(input) {
+    return this.t.request("POST", "/compute/releases", { json: input });
+  }
+  /** 409 if `eval_score` is below the gate. */
+  promote(name, version, minEvalScore = 0.8) {
+    return this.t.request("POST", "/compute/releases/promote", {
+      json: { name, version, min_eval_score: minEvalScore }
+    });
+  }
+  deploy(providerId, name, channel = "production", extra = {}) {
+    return this.t.request("POST", `/compute/providers/${providerId}/releases/deploy`, {
+      json: { name, channel, ...extra }
+    });
+  }
+};
+var ComputeControlResource = class {
+  constructor(t, providerId) {
+    this.t = t;
+    this.base = `/compute/providers/${providerId}`;
+  }
+  t;
+  base;
+  listTemplates() {
+    return this.t.request("GET", `${this.base}/templates`);
+  }
+  saveTemplate(name, imageName, extra = {}) {
+    return this.t.request("POST", `${this.base}/templates`, {
+      json: { name, image_name: imageName, ...extra }
+    });
+  }
+  deleteTemplate(templateId) {
+    return this.t.request("DELETE", `${this.base}/templates/${templateId}`);
+  }
+  listEndpoints() {
+    return this.t.request("GET", `${this.base}/endpoints`);
+  }
+  createEndpoint(templateId, name, extra = {}) {
+    return this.t.request("POST", `${this.base}/endpoints`, {
+      json: { template_id: templateId, name, ...extra }
+    });
+  }
+  updateEndpoint(endpointId, patch) {
+    return this.t.request("PATCH", `${this.base}/endpoints/${endpointId}`, {
+      json: { patch }
+    });
+  }
+  deleteEndpoint(endpointId) {
+    return this.t.request("DELETE", `${this.base}/endpoints/${endpointId}`);
+  }
+  endpointHealth(endpointId) {
+    return this.t.request("GET", `${this.base}/endpoints/${endpointId}/health`);
+  }
+  /** `sync: true` long-polls server-side up to `timeout_s` — pass a matching
+   *  `signal` (or raise the client `timeoutMs`) for long jobs. */
+  submitJob(endpointId, input, opts = {}) {
+    return this.t.request("POST", `${this.base}/endpoints/${endpointId}/jobs`, {
+      json: { input, sync: opts.sync ?? false, webhook: opts.webhook, timeout_s: opts.timeout_s }
+    });
+  }
+  jobStatus(endpointId, jobId) {
+    return this.t.request("GET", `${this.base}/endpoints/${endpointId}/jobs/${jobId}`);
+  }
+  cancelJob(endpointId, jobId) {
+    return this.t.request("POST", `${this.base}/endpoints/${endpointId}/jobs/${jobId}/cancel`);
+  }
+  listPods() {
+    return this.t.request("GET", `${this.base}/pods`);
+  }
+  createPod(name, imageName, extra = {}) {
+    return this.t.request("POST", `${this.base}/pods`, {
+      json: { name, image_name: imageName, ...extra }
+    });
+  }
+  stopPod(podId) {
+    return this.t.request("POST", `${this.base}/pods/${podId}/stop`);
+  }
+  terminatePod(podId) {
+    return this.t.request("DELETE", `${this.base}/pods/${podId}`);
+  }
+};
+var ComputeResource = class {
+  constructor(t) {
+    this.t = t;
+    this.providers = new ComputeProvidersResource(t);
+    this.releases = new ComputeReleasesResource(t);
+  }
+  t;
+  providers;
+  releases;
+  selectModel(objective, opts = {}) {
+    return this.t.request("POST", "/compute/vision/select-model", {
+      json: { objective, ...opts }
+    });
+  }
+  generateSpec(objective, opts = {}) {
+    return this.t.request("POST", "/compute/spec/generate", {
+      json: { objective, base_image: opts.base_image ?? "python:3.11-slim", ...opts }
+    });
+  }
+  visionCount(imageUrl, instruction, opts = {}) {
+    return this.t.request("POST", "/compute/vision/count", {
+      json: { image_url: imageUrl, instruction, ...opts }
+    });
+  }
+  /** Factory (no HTTP) — control plane scoped to one provider. */
+  control(providerId) {
+    return new ComputeControlResource(this.t, providerId);
+  }
+};
+var InferenceResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  complete(prompt, opts = {}) {
+    return this.t.request("POST", "/inference/complete", {
+      json: {
+        prompt,
+        provider: opts.provider ?? "groq",
+        model: opts.model ?? "llama-3.3-70b-versatile",
+        system_prompt: opts.system_prompt,
+        temperature: opts.temperature ?? 0,
+        max_tokens: opts.max_tokens ?? 4096
+      }
+    });
+  }
+  chat(messages, opts = {}) {
+    const body = {
+      messages,
+      provider: opts.provider ?? "groq",
+      model: opts.model ?? "llama-3.3-70b-versatile",
+      temperature: opts.temperature ?? 0,
+      max_tokens: opts.max_tokens ?? 4096
+    };
+    if (opts.rag_sources) {
+      body.rag_sources = opts.rag_sources;
+      body.rag_limit = opts.rag_limit ?? 5;
+    }
+    return this.t.request("POST", "/inference/chat", { json: body });
+  }
+  models() {
+    return this.t.request("GET", "/inference/models");
+  }
+  collections() {
+    return this.t.request("GET", "/inference/collections");
+  }
+  async chatWithRag(query, opts = {}) {
+    const payload = await this.t.request("POST", "/mcp/tools/call", {
+      json: {
+        name: "chat_with_rag",
+        arguments: {
+          query,
+          sources: opts.sources ?? ["all"],
+          limit: opts.limit ?? 6,
+          provider: opts.provider ?? "groq",
+          model: opts.model ?? "llama-3.3-70b-versatile",
+          temperature: opts.temperature ?? 0.2,
+          max_tokens: opts.max_tokens ?? 512,
+          system: opts.system
+        }
+      }
+    });
+    return payload.result ?? payload;
+  }
+  auditTrail(opts = {}) {
+    return this.t.request("GET", "/inference/audit-trail", {
+      params: { limit: opts.limit ?? 50, provider: opts.provider }
+    });
+  }
+};
+var CodegenResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  /** kind ∈ transform|script */
+  generate(objective, kind = "transform", context) {
+    return this.t.request("POST", "/codegen/generate", { json: { objective, kind, context } });
+  }
+};
+var CorrelationResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  quickLinks(value, kind) {
+    return this.t.request("POST", "/correlation/quick-links", { json: { value, kind } });
+  }
+  startChain(value, opts = {}) {
+    return this.t.request("POST", "/correlation/chain", { json: { value, ...opts } });
+  }
+  /** Poll until `status === "done"`. */
+  getChain(taskId) {
+    return this.t.request("GET", `/correlation/chain/${taskId}`);
+  }
+  /** Opt-in: materializes the chain graph into the ontology. */
+  saveChain(taskId, nodeIds) {
+    return this.t.request("POST", `/correlation/chain/${taskId}/save`, {
+      json: nodeIds ? { node_ids: nodeIds } : {}
+    });
+  }
+};
+var SituationalResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  nearby(nodeId, opts = {}) {
+    return this.t.request("GET", "/api/v1/situational/nearby", {
+      params: { node_id: nodeId, ...opts, kinds: opts.kinds?.join(",") }
+    });
+  }
+  correlations(nodeId) {
+    return this.t.request("GET", "/api/v1/situational/correlations", {
+      params: { node_id: nodeId }
+    });
+  }
+  correlate(anchorNodeId, opts = {}) {
+    return this.t.request("POST", "/api/v1/situational/correlations", {
+      json: { anchor_node_id: anchorNodeId, ...opts }
+    });
+  }
+  /** Reversible — removes the correlation edge. */
+  cut(edgeId) {
+    return this.t.request("DELETE", `/api/v1/situational/correlations/${edgeId}`);
+  }
+};
+var MergeResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  suggestTarget(nodeType, canonical) {
+    return this.t.request("POST", "/ontology/merge/suggest-target", {
+      json: { node_type: nodeType, canonical }
+    });
+  }
+  /** Pass `result_payload` (raw) OR `properties` (ready). */
+  preview(target, opts = {}) {
+    return this.t.request("POST", "/ontology/merge/preview", { json: { target, ...opts } });
+  }
+  /** `field_resolutions`: `{field: "keep"|"replace"|"append"}`;
+   *  `link`: `{target_object_id, relation_type, metadata?}`. */
+  apply(target, opts = {}) {
+    return this.t.request("POST", "/ontology/merge/apply", { json: { target, ...opts } });
+  }
+};
+
+// src/resources/domain.ts
+var AtlasLayersResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/atlas/layers");
+  }
+  create(name, kind, extra = {}) {
+    const body = { name, kind };
+    for (const [k, v] of Object.entries(extra)) if (v !== void 0 && v !== null) body[k] = v;
+    return this.t.request("POST", "/atlas/layers", { json: body });
+  }
+  delete(layerId) {
+    return this.t.request("DELETE", `/atlas/layers/${layerId}`);
+  }
+  /** KML content travels inside the JSON body (not multipart) — same as Python. */
+  importKml(layerId, kmlText) {
+    return this.t.request("POST", `/atlas/layers/${layerId}/import`, {
+      json: { _kml_bytes_b64: kmlText }
+    });
+  }
+};
+var AtlasEvaluationResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  status() {
+    return this.t.request("GET", "/atlas/evaluation/status");
+  }
+  runOnce() {
+    return this.t.request("POST", "/atlas/evaluation/run-once");
+  }
+};
+var AtlasResource = class {
+  layers;
+  evaluation;
+  constructor(t) {
+    this.layers = new AtlasLayersResource(t);
+    this.evaluation = new AtlasEvaluationResource(t);
+  }
+};
+var BriefingResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  get(slug) {
+    return this.t.request("GET", `/campaign/home-briefing/${slug}`);
+  }
+  refresh(slug) {
+    return this.t.request("POST", `/campaign/home-briefing/${slug}/refresh`);
+  }
+  crisisPlan(slug) {
+    return this.t.request("POST", `/campaign/home-briefing/${slug}/crisis-plan`);
+  }
+};
+var CctvBookmarksResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  create(streamId, input) {
+    return this.t.request("POST", `/api/v1/cctv/streams/${streamId}/bookmarks`, { json: input });
+  }
+  list(streamId, opts = {}) {
+    return this.t.request("GET", `/api/v1/cctv/streams/${streamId}/bookmarks`, { params: opts });
+  }
+  delete(bookmarkId) {
+    return this.t.request("DELETE", `/api/v1/cctv/bookmarks/${bookmarkId}`);
+  }
+};
+var CctvGcpsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  put(streamId, gcps) {
+    return this.t.request("PUT", `/api/v1/cctv/streams/${streamId}/gcps`, { json: { gcps } });
+  }
+  get(streamId) {
+    return this.t.request("GET", `/api/v1/cctv/streams/${streamId}/gcps`);
+  }
+  delete(streamId) {
+    return this.t.request("DELETE", `/api/v1/cctv/streams/${streamId}/gcps`);
+  }
+};
+var CctvHotlistResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(activeOnly) {
+    return this.t.request("GET", "/api/v1/cctv/hotlist", { params: { active_only: activeOnly } });
+  }
+  add(plate, opts = {}) {
+    return this.t.request("POST", "/api/v1/cctv/hotlist", {
+      json: { plate, reason: opts.reason, severity: opts.severity ?? "medium" }
+    });
+  }
+  remove(watchedId) {
+    return this.t.request("DELETE", `/api/v1/cctv/hotlist/${watchedId}`);
+  }
+};
+var CctvResource = class {
+  constructor(t) {
+    this.t = t;
+    this.bookmarks = new CctvBookmarksResource(t);
+    this.gcps = new CctvGcpsResource(t);
+    this.hotlist = new CctvHotlistResource(t);
+  }
+  t;
+  bookmarks;
+  gcps;
+  hotlist;
+  streamsPage(opts = {}) {
+    return this.t.request("GET", "/api/v1/cctv/streams/page", { params: opts });
+  }
+  detections(streamId, opts = {}) {
+    return this.t.request("GET", `/api/v1/cctv/streams/${streamId}/detections`, { params: opts });
+  }
+  detectorClasses() {
+    return this.t.request("GET", "/api/v1/cctv/detector/classes");
+  }
+  presets() {
+    return this.t.request("GET", "/api/v1/cctv/presets");
+  }
+  bridgeBackfill() {
+    return this.t.request("POST", "/api/v1/cctv/bridge/backfill");
+  }
+  /** 202 — returns a provider job to poll. */
+  detectNow(streamId, opts = {}) {
+    return this.t.request("POST", `/api/v1/cctv/streams/${streamId}/detect-now`, { json: opts });
+  }
+  /** 202 — export job; poll with `exportStatus`. */
+  exportClip(streamId, opts = {}) {
+    return this.t.request("POST", `/api/v1/cctv/streams/${streamId}/export`, { json: opts });
+  }
+  exportStatus(jobId) {
+    return this.t.request("GET", `/api/v1/cctv/exports/${jobId}`);
+  }
+  recordings(streamId, opts = {}) {
+    return this.t.request("GET", `/api/v1/cctv/streams/${streamId}/recordings`, { params: opts });
+  }
+  recordingStatus(streamId) {
+    return this.t.request("GET", `/api/v1/cctv/streams/${streamId}/recording`);
+  }
+  /** action ∈ start|stop */
+  recordingControl(streamId, action, cadence) {
+    return this.t.request("POST", `/api/v1/cctv/streams/${streamId}/recording`, {
+      json: { action, cadence }
+    });
+  }
+  /** Returns the raw HLS VOD playlist text (m3u8), not JSON. */
+  recordingsPlaylist(streamId, opts = {}) {
+    return this.t.request("GET", `/api/v1/cctv/streams/${streamId}/recordings/playlist.m3u8`, {
+      params: opts
+    });
+  }
+};
+var EdgeResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  /**
+   * Issue a single-use pairing code (short TTL). The plaintext `code` appears
+   * ONLY in this response (hash at rest).
+   *
+   * `grants` GRANTS gestures to whichever device redeems the code (allowlist;
+   * today `["retry"]`, so a desk app can ask the station to reconnect a
+   * number). Empty — the default — is **read only**: least privilege, and
+   * granting has to be a choice. The grant travels from the code to the node
+   * and dies with it on `revoke`.
+   *
+   * Even when granted, the device never receives the gesture's ADDRESS
+   * (`agent_id`/`skill_key`): it sends the verb and the server routes it.
+   * Perm: `connectors.manage`.
+   */
+  createPairingCode(opts = {}) {
+    return this.t.request("POST", "/api/v1/edge/pairing-codes", { json: opts });
+  }
+  /** Nodes carry an additive `kind` field — see {@link EdgeNode}. */
+  listNodes() {
+    return this.t.request("GET", "/api/v1/edge/nodes");
+  }
+  listDiscovered() {
+    return this.t.request("GET", "/api/v1/edge/discovered");
+  }
+  revoke(edgeId) {
+    return this.t.request("POST", `/api/v1/edge/${edgeId}/revoke`);
+  }
+  setExpectedVersion(version) {
+    return this.t.request("PUT", "/api/v1/edge/expected-version", { json: { version } });
+  }
+  getExpectedVersion() {
+    return this.t.request("GET", "/api/v1/edge/expected-version");
+  }
+};
+var VideoStreamsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/video/streams");
+  }
+  create(input) {
+    return this.t.request("POST", "/video/streams", { json: input });
+  }
+  delete(streamId) {
+    return this.t.request("DELETE", `/video/streams/${streamId}`);
+  }
+};
+var VideoResource = class {
+  constructor(t) {
+    this.t = t;
+    this.streams = new VideoStreamsResource(t);
+  }
+  t;
+  streams;
+  listDetections(streamId, opts = {}) {
+    return this.t.request("GET", "/video/detections", {
+      params: { stream_id: streamId, ...opts }
+    });
+  }
+  submitDetection(detection) {
+    return this.t.request("POST", "/video/detections", { json: detection });
+  }
+  listTags(streamId) {
+    return this.t.request("GET", "/video/tags", { params: { stream_id: streamId } });
+  }
+  submitTag(tag) {
+    return this.t.request("POST", "/video/tags", { json: tag });
+  }
+  soakHeatmap(streamId, from, to, precision) {
+    return this.t.request("GET", "/video/soak", {
+      params: { stream_id: streamId, from, to, precision }
+    });
+  }
+  createExport(streamId, frameRange, redactions) {
+    return this.t.request("POST", "/video/exports", {
+      json: { stream_id: streamId, frame_range: frameRange, redactions }
+    });
+  }
+  getExport(exportId) {
+    return this.t.request("GET", `/video/exports/${exportId}`);
+  }
+};
+var ComunicadosResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/platform/v23/comunicados", { params: opts });
+  }
+  listActive() {
+    return this.t.request("GET", "/platform/v23/comunicados/active");
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/comunicados", { json: input });
+  }
+  /** Sparse patch — only provided keys are sent. */
+  patch(comunicadoId, patch) {
+    const body = Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== void 0));
+    return this.t.request("PATCH", `/platform/v23/comunicados/${comunicadoId}`, { json: body });
+  }
+  /** Soft delete. */
+  delete(comunicadoId) {
+    return this.t.request("DELETE", `/platform/v23/comunicados/${comunicadoId}`);
+  }
+  /** Idempotent per-user dismissal. */
+  dismissMe(comunicadoId) {
+    return this.t.request("POST", `/platform/v23/comunicados/${comunicadoId}/dismiss/me`, {
+      json: {}
+    });
+  }
+};
+var CampaignBriefingResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  refresh(opts = {}) {
+    return this.t.request("POST", "/campaign/home-briefing/refresh", {
+      json: { default_modo_inicial: "B", ...opts }
+    });
+  }
+  get(candidatoSlug, includeHeadline) {
+    return this.t.request("GET", "/campaign/home-briefing", {
+      params: {
+        candidato_slug: candidatoSlug,
+        include_headline: includeHeadline === void 0 ? void 0 : String(includeHeadline)
+      }
+    });
+  }
+  /** 409 when the briefing is in crisis mode. */
+  regenerateHeadline(candidatoSlug) {
+    return this.t.request("POST", "/campaign/home-briefing/headline/regenerate", {
+      json: { candidato_slug: candidatoSlug }
+    });
+  }
+  /** duration_hours ∈ 1..168 (default 24). */
+  overrideModo(candidatoSlug, novoModo, durationHours = 24) {
+    return this.t.request("POST", "/campaign/home-briefing/modo/override", {
+      json: { candidato_slug: candidatoSlug, novo_modo: novoModo, duration_hours: durationHours }
+    });
+  }
+};
+var CampaignResource = class {
+  briefing;
+  constructor(t) {
+    this.briefing = new CampaignBriefingResource(t);
+  }
+};
+
+// src/resources/collab.ts
+var FormsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  submit(formKey, payload, opts = {}) {
+    return this.t.request("POST", "/platform/v23/forms/submit", {
+      json: {
+        form_key: formKey,
+        payload,
+        visibility_policy: opts.visibility_policy ?? "requires_auth",
+        ...opts
+      }
+    });
+  }
+  listSubmissions(opts = {}) {
+    return this.t.request("GET", "/platform/v23/forms/submissions", { params: opts });
+  }
+};
+var AppShellSection = class {
+  constructor(t, path) {
+    this.t = t;
+    this.path = path;
+  }
+  t;
+  path;
+  get() {
+    return this.t.request("GET", this.path);
+  }
+  put(value) {
+    return this.t.request("PUT", this.path, { json: value });
+  }
+};
+var AppShellResource = class {
+  constructor(t) {
+    this.t = t;
+    this.banner = new AppShellSection(t, "/platform/v23/app-shell/banner");
+    this.footer = new AppShellSection(t, "/platform/v23/app-shell/footer");
+    this.userMenu = new AppShellSection(t, "/platform/v23/app-shell/user-menu");
+    this.sidenav = new AppShellSection(t, "/platform/v23/app-shell/sidenav");
+    this.homepage = new AppShellSection(t, "/platform/v23/app-shell/homepage");
+  }
+  t;
+  banner;
+  footer;
+  userMenu;
+  sidenav;
+  homepage;
+  getMe() {
+    return this.t.request("GET", "/platform/v23/app-shell/me");
+  }
+  putMe(config) {
+    return this.t.request("PUT", "/platform/v23/app-shell/me", { json: config });
+  }
+  getTenant() {
+    return this.t.request("GET", "/platform/v23/app-shell/tenant");
+  }
+  putTenant(config) {
+    return this.t.request("PUT", "/platform/v23/app-shell/tenant", { json: config });
+  }
+};
+var ProjectConstraintsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  get(projectId) {
+    return this.t.request("GET", `/projects/${projectId}/constraints`);
+  }
+  put(projectId, opts = {}) {
+    return this.t.request("PUT", `/projects/${projectId}/constraints`, {
+      json: { mode: opts.mode ?? "none", ...opts }
+    });
+  }
+  clear(projectId) {
+    return this.t.request("DELETE", `/projects/${projectId}/constraints`);
+  }
+  /** Report-only — deletes nothing. */
+  revalidate(projectId) {
+    return this.t.request("POST", `/projects/${projectId}/constraints/revalidate`);
+  }
+};
+var ProjectsResource = class {
+  constructor(t) {
+    this.t = t;
+    this.constraints = new ProjectConstraintsResource(t);
+  }
+  t;
+  constraints;
+  /** `spaceId: null` removes the project from its Space. */
+  move(projectId, spaceId) {
+    return this.t.request("PATCH", `/projects/${projectId}/move`, {
+      json: { space_id: spaceId }
+    });
+  }
+};
+var OrganizationsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/organizations", { params: opts });
+  }
+  get(organizationId) {
+    return this.t.request("GET", `/organizations/${organizationId}`);
+  }
+  listGuests(organizationId, includeRevoked = false) {
+    return this.t.request("GET", `/organizations/${organizationId}/guests`, {
+      params: { include_revoked: includeRevoked }
+    });
+  }
+  inviteGuest(organizationId, userId, expiresAt) {
+    return this.t.request("POST", `/organizations/${organizationId}/guests`, {
+      json: { user_id: userId, expires_at: expiresAt }
+    });
+  }
+  revokeGuest(organizationId, userId) {
+    return this.t.request("DELETE", `/organizations/${organizationId}/guests/${userId}`);
+  }
+};
+var SpacesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/spaces", { params: opts });
+  }
+  get(spaceId) {
+    return this.t.request("GET", `/spaces/${spaceId}`);
+  }
+  create(slug, displayName, description) {
+    return this.t.request("POST", "/spaces", {
+      json: { slug, display_name: displayName, description }
+    });
+  }
+  update(spaceId, patch) {
+    return this.t.request("PATCH", `/spaces/${spaceId}`, { json: patch });
+  }
+  addOrganization(spaceId, tenantId) {
+    return this.t.request("POST", `/spaces/${spaceId}/organizations`, {
+      json: { tenant_id: tenantId }
+    });
+  }
+  removeOrganization(spaceId, tenantId) {
+    return this.t.request("DELETE", `/spaces/${spaceId}/organizations/${tenantId}`);
+  }
+};
+var SolutionsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  design(problem, opts = {}) {
+    return this.t.request("POST", "/platform/v23/solutions/design", {
+      json: { problem, ...opts }
+    });
+  }
+  /** Accept-flags travel nested under `accept`; blueprint/diagram_id/app_id/linked_sources stay top-level. */
+  materialize(blueprint, accept = {}, opts = {}) {
+    return this.t.request("POST", "/platform/v23/solutions/materialize", {
+      json: { blueprint, accept, ...opts }
+    });
+  }
+  /** depth ∈ lean|full */
+  designGraph(problem, opts = {}) {
+    return this.t.request("POST", "/platform/v23/solutions/design-graph", {
+      json: { problem, depth: opts.depth ?? "lean", wizard: opts.wizard }
+    });
+  }
+  mergeGraph(currentGraph, baseBlueprint, incomingBlueprint) {
+    return this.t.request("POST", "/platform/v23/solutions/merge-graph", {
+      json: {
+        current_graph: currentGraph,
+        base_blueprint: baseBlueprint,
+        incoming_blueprint: incomingBlueprint
+      }
+    });
+  }
+  listPatterns() {
+    return this.t.request("GET", "/platform/v23/solutions/patterns");
+  }
+  listDiagrams(opts = {}) {
+    return this.t.request("GET", "/platform/v23/solutions/diagrams", { params: opts });
+  }
+  get(diagramId) {
+    return this.t.request("GET", `/platform/v23/solutions/diagrams/${diagramId}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/solutions/diagrams", { json: input });
+  }
+  /** Save == publish. */
+  save(diagramId, input) {
+    return this.t.request("PATCH", `/platform/v23/solutions/diagrams/${diagramId}`, {
+      json: input
+    });
+  }
+  delete(diagramId) {
+    return this.t.request("DELETE", `/platform/v23/solutions/diagrams/${diagramId}`);
+  }
+  versions(diagramId) {
+    return this.t.request("GET", `/platform/v23/solutions/diagrams/${diagramId}/versions`);
+  }
+  walkthrough(diagramId) {
+    return this.t.request("POST", `/platform/v23/solutions/diagrams/${diagramId}/walkthrough`, {
+      json: {}
+    });
+  }
+  implementations(graph, nodeId, opts = {}) {
+    return this.t.request("POST", "/platform/v23/solutions/implementations", {
+      json: { graph, node_id: nodeId, problem: opts.problem ?? "", wizard: opts.wizard }
+    });
+  }
+  expandNode(graph, nodeId, planId, wizard) {
+    return this.t.request("POST", "/platform/v23/solutions/expand-node", {
+      json: { graph, node_id: nodeId, plan_id: planId, wizard }
+    });
+  }
+  ontologyModel(prompt) {
+    return this.t.request("POST", "/platform/v23/solutions/ontology-model", { json: { prompt } });
+  }
+  fromLineage(events) {
+    return this.t.request("POST", "/platform/v23/solutions/from-lineage", {
+      json: events ? { events } : {}
+    });
+  }
+  teardownPlan(appId) {
+    return this.t.request("GET", `/workshop/apps/${appId}/teardown-plan`);
+  }
+  teardown(appId) {
+    return this.t.request("DELETE", `/workshop/apps/${appId}`, {
+      params: { teardown_build: "true" }
+    });
+  }
+  marketplaceListings(opts = {}) {
+    return this.t.request("GET", "/solutions/marketplace/listings", {
+      params: { status: opts.status ?? "published", q: opts.q, tag: opts.tag, category: opts.category }
+    });
+  }
+  marketplaceDetail(listingId) {
+    return this.t.request("GET", `/solutions/marketplace/listings/${listingId}`);
+  }
+  marketplacePublish(diagramId, opts = {}) {
+    return this.t.request("POST", "/solutions/marketplace/listings", {
+      json: { diagram_id: diagramId, category: opts.category ?? "", ...opts }
+    });
+  }
+  /** Re-materializes the listing in the caller's tenant. */
+  marketplaceInstall(listingId) {
+    return this.t.request("POST", `/solutions/marketplace/listings/${listingId}/install`);
+  }
+  marketplacePatch(listingId, fields) {
+    return this.t.request("PATCH", `/solutions/marketplace/listings/${listingId}`, {
+      json: fields
+    });
+  }
+};
+
+// src/resources/workspaces.ts
+var WorkspaceVersionsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(workspaceId) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/versions`);
+  }
+  get(workspaceId, versionNumber) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/versions/${versionNumber}`);
+  }
+  republish(workspaceId, versionNumber, message) {
+    return this.t.request(
+      "POST",
+      `/workspaces/${workspaceId}/versions/${versionNumber}/republish`,
+      { json: message ? { message } : {} }
+    );
+  }
+};
+var WorkspacesResource = class {
+  constructor(t) {
+    this.t = t;
+    this.versions = new WorkspaceVersionsResource(t);
+  }
+  t;
+  versions;
+  list(opts = {}) {
+    return this.t.request("GET", "/workspaces", { params: opts });
+  }
+  get(workspaceId) {
+    return this.t.request("GET", `/workspaces/${workspaceId}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/workspaces", { json: input });
+  }
+  /** Save == immediate publish — bumps version + snapshot. */
+  publish(workspaceId, config, message) {
+    return this.t.request("PATCH", `/workspaces/${workspaceId}`, { json: { config, message } });
+  }
+  /** Soft delete (`active=false`). */
+  delete(workspaceId) {
+    return this.t.request("DELETE", `/workspaces/${workspaceId}`);
+  }
+  getNavigation(workspaceId) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/navigation`);
+  }
+  setNavigation(workspaceId, opts = {}) {
+    return this.t.request("PUT", `/workspaces/${workspaceId}/navigation`, {
+      json: { navigate_out_allowed: opts.navigate_out_allowed ?? true, ...opts }
+    });
+  }
+  listPromotions(workspaceId) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/promotions`);
+  }
+  /** Idempotent. */
+  promote(workspaceId, organizationId, ordering = 0) {
+    return this.t.request("POST", `/workspaces/${workspaceId}/promotions`, {
+      json: { organization_id: organizationId, ordering }
+    });
+  }
+  unpromote(workspaceId, organizationId) {
+    return this.t.request("DELETE", `/workspaces/${workspaceId}/promotions/${organizationId}`);
+  }
+  listPromotedForOrganization(organizationId) {
+    return this.t.request("GET", `/organizations/${organizationId}/promoted-workspaces`);
+  }
+  getKiosk(workspaceId) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/kiosk`);
+  }
+  setKiosk(workspaceId, opts = {}) {
+    return this.t.request("PUT", `/workspaces/${workspaceId}/kiosk`, {
+      json: {
+        hide_chrome: opts.hide_chrome ?? true,
+        allow_exit: opts.allow_exit ?? true,
+        auto_fullscreen: opts.auto_fullscreen ?? true,
+        message: opts.message
+      }
+    });
+  }
+  startKioskSession(workspaceId, clientInfo) {
+    return this.t.request("POST", `/workspaces/${workspaceId}/kiosk/sessions`, {
+      json: clientInfo ? { client_info: clientInfo } : {}
+    });
+  }
+  endKioskSession(workspaceId, sessionId) {
+    return this.t.request("POST", `/workspaces/${workspaceId}/kiosk/sessions/${sessionId}/end`);
+  }
+  listKioskSessions(workspaceId, opts = {}) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/kiosk/sessions`, { params: opts });
+  }
+};
+var WorkspaceUpdatesResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(workspaceId, includeArchived = false) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/updates`, {
+      params: { include_archived: includeArchived }
+    });
+  }
+  /** Active updates not yet seen by the caller. */
+  listUnseen(workspaceId) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/updates/unseen`);
+  }
+  get(workspaceId, updateId) {
+    return this.t.request("GET", `/workspaces/${workspaceId}/updates/${updateId}`);
+  }
+  create(workspaceId, input) {
+    return this.t.request("POST", `/workspaces/${workspaceId}/updates`, { json: input });
+  }
+  patch(workspaceId, updateId, patch) {
+    return this.t.request("PATCH", `/workspaces/${workspaceId}/updates/${updateId}`, {
+      json: patch
+    });
+  }
+  archive(workspaceId, updateId) {
+    return this.t.request("POST", `/workspaces/${workspaceId}/updates/${updateId}/archive`);
+  }
+  /** Hard delete — cascades pages + views. */
+  delete(workspaceId, updateId) {
+    return this.t.request("DELETE", `/workspaces/${workspaceId}/updates/${updateId}`);
+  }
+  markSeen(workspaceId, updateId, dismissed = false) {
+    return this.t.request("POST", `/workspaces/${workspaceId}/updates/${updateId}/seen`, {
+      json: { dismissed }
+    });
+  }
+};
+
+// src/resources/platformVersions.ts
+var V22ActionLogResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  record(input) {
+    return this.t.request("POST", "/platform/v22/action-log", { json: input });
+  }
+  list(opts = {}) {
+    return this.t.request("GET", "/platform/v22/action-log", { params: opts });
+  }
+};
+var V22NotepadResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  create(title, opts = {}) {
+    return this.t.request("POST", "/platform/v22/notepad", { json: { title, ...opts } });
+  }
+  freeze(docId) {
+    return this.t.request("POST", `/platform/v22/notepad/${docId}/freeze`);
+  }
+  instantiate(templateId, title, variables) {
+    return this.t.request("POST", `/platform/v22/notepad/${templateId}/instantiate`, {
+      json: { title, variables }
+    });
+  }
+};
+var V22QuiverResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  create(input) {
+    return this.t.request("POST", "/platform/v22/quiver", { json: input });
+  }
+  render(dashId, opts = {}) {
+    return this.t.request("POST", `/platform/v22/quiver/${dashId}/render`, { json: opts });
+  }
+};
+var PlatformV22Resource = class {
+  constructor(t) {
+    this.t = t;
+    this.actionLog = new V22ActionLogResource(t);
+    this.notepad = new V22NotepadResource(t);
+    this.quiver = new V22QuiverResource(t);
+  }
+  t;
+  actionLog;
+  notepad;
+  quiver;
+  /** Returns the transformed value (unwraps the response's `value` field). */
+  async applyVariableTransform(kind, inputs) {
+    const payload = await this.t.request("POST", "/platform/v22/variable-transforms/apply", {
+      json: { kind, inputs }
+    });
+    return payload.value;
+  }
+  recordUsage(input) {
+    return this.t.request("POST", "/platform/v22/ontology-usage/record", { json: input });
+  }
+  queryUsage(opts = {}) {
+    return this.t.request("GET", "/platform/v22/ontology-usage", {
+      params: { days: 30, ...opts }
+    });
+  }
+};
+var V23LogicResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v23/aip-logic");
+  }
+  get(fid) {
+    return this.t.request("GET", `/platform/v23/aip-logic/${fid}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/aip-logic", { json: input });
+  }
+  update(fid, patch) {
+    return this.t.request("PUT", `/platform/v23/aip-logic/${fid}`, { json: patch });
+  }
+  delete(fid) {
+    return this.t.request("DELETE", `/platform/v23/aip-logic/${fid}`);
+  }
+  invoke(fid, inputs) {
+    return this.t.request("POST", `/platform/v23/aip-logic/${fid}/invoke`, {
+      json: { inputs: inputs ?? {} }
+    });
+  }
+  addTest(fid, input) {
+    return this.t.request("POST", `/platform/v23/aip-logic/${fid}/tests`, { json: input });
+  }
+  runTest(fid, testId) {
+    return this.t.request("POST", `/platform/v23/aip-logic/${fid}/tests/${testId}/run`);
+  }
+};
+var V23ActionsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v23/action-types");
+  }
+  get(aid) {
+    return this.t.request("GET", `/platform/v23/action-types/${aid}`);
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/action-types", { json: input });
+  }
+  update(aid, patch) {
+    return this.t.request("PUT", `/platform/v23/action-types/${aid}`, { json: patch });
+  }
+  delete(aid) {
+    return this.t.request("DELETE", `/platform/v23/action-types/${aid}`);
+  }
+  execute(aid, inputs, note) {
+    return this.t.request("POST", `/platform/v23/action-types/${aid}/execute`, {
+      json: { input: inputs ?? {}, note }
+    });
+  }
+  plan(steps) {
+    return this.t.request("POST", "/platform/v23/action-types/plan", { json: { steps } });
+  }
+  executions(aid) {
+    return this.t.request("GET", `/platform/v23/action-types/${aid}/executions`);
+  }
+};
+var V23AssistResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list(opts = {}) {
+    return this.t.request("GET", "/platform/v23/aip-assist", { params: opts });
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/aip-assist", { json: input });
+  }
+  delete(cid) {
+    return this.t.request("DELETE", `/platform/v23/aip-assist/${cid}`);
+  }
+  suggest(input) {
+    return this.t.request("POST", "/platform/v23/aip-assist/suggest", { json: input });
+  }
+};
+var V23PipelineResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request("GET", "/platform/v23/pipeline");
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/pipeline", { json: input });
+  }
+  update(pid, patch) {
+    return this.t.request("PUT", `/platform/v23/pipeline/${pid}`, { json: patch });
+  }
+  delete(pid) {
+    return this.t.request("DELETE", `/platform/v23/pipeline/${pid}`);
+  }
+  run(pid, opts = {}) {
+    return this.t.request("POST", `/platform/v23/pipeline/${pid}/run`, { json: opts });
+  }
+  runs(pid, limit = 50) {
+    return this.t.request("GET", `/platform/v23/pipeline/${pid}/runs`, { params: { limit } });
+  }
+};
+var V23StylesBrandResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  get() {
+    return this.t.request("GET", "/platform/v23/styles/brand");
+  }
+  update(patch) {
+    return this.t.request("PUT", "/platform/v23/styles/brand", { json: patch });
+  }
+  /** Unauthenticated-safe read. */
+  getPublic(tenant) {
+    return this.t.request("GET", "/platform/v23/styles/brand/public", { params: { tenant } });
+  }
+};
+var V23StylesResource = class {
+  constructor(t) {
+    this.t = t;
+    this.brand = new V23StylesBrandResource(t);
+  }
+  t;
+  brand;
+  get() {
+    return this.t.request("GET", "/platform/v23/styles");
+  }
+  update(tokens, message) {
+    return this.t.request("PUT", "/platform/v23/styles", { json: { tokens, message } });
+  }
+  getRegionColors() {
+    return this.t.request("GET", "/platform/v23/styles/region-colors");
+  }
+  updateRegionColors(patch) {
+    return this.t.request("PUT", "/platform/v23/styles/region-colors", { json: patch });
+  }
+  /** Multipart upload (the only non-JSON write in the v2x surfaces). */
+  uploadLogo(file, filename = "logo.png") {
+    const form = new FormData();
+    form.append("file", file, filename);
+    return this.t.request("POST", "/platform/v23/styles/upload/logo", { form });
+  }
+};
+function crudFactory(t, base) {
+  return {
+    list: () => t.request("GET", base),
+    create: (input) => t.request("POST", base, { json: input }),
+    delete: (id) => t.request("DELETE", `${base}/${id}`)
+  };
+}
+var PlatformV23Resource = class {
+  constructor(t) {
+    this.t = t;
+    this.logic = new V23LogicResource(t);
+    this.actions = new V23ActionsResource(t);
+    this.assist = new V23AssistResource(t);
+    this.pipeline = new V23PipelineResource(t);
+    this.styles = new V23StylesResource(t);
+    const quiverBase = "/platform/v23/quiver";
+    this.quiver = {
+      ...crudFactory(t, quiverBase),
+      update: (id, patch) => t.request("PUT", `${quiverBase}/${id}`, { json: patch }),
+      run: (id) => t.request("POST", `${quiverBase}/${id}/run`)
+    };
+    const connectorsBase = "/platform/v23/connectors";
+    this.connectors = {
+      list: () => t.request("GET", connectorsBase),
+      register: (input) => t.request("POST", connectorsBase, { json: input }),
+      delete: (id) => t.request("DELETE", `${connectorsBase}/${id}`),
+      heartbeat: (id, status = "connected", error) => t.request("POST", `${connectorsBase}/${id}/heartbeat`, { json: { status, error } })
+    };
+    const automateBase = "/platform/v23/automate";
+    this.automate = {
+      ...crudFactory(t, automateBase),
+      fire: (id) => t.request("POST", `${automateBase}/${id}/fire`),
+      runs: (id) => t.request("GET", `${automateBase}/${id}/runs`)
+    };
+    const healthBase = "/platform/v23/health";
+    this.health = {
+      ...crudFactory(t, healthBase),
+      run: (id) => t.request("POST", `${healthBase}/${id}/run`)
+    };
+    const contourBase = "/platform/v23/contour";
+    this.contour = {
+      ...crudFactory(t, contourBase),
+      evaluate: (id, limit = 50) => t.request("POST", `${contourBase}/${id}/evaluate`, { json: { limit } })
+    };
+    this.vertex = crudFactory(t, "/platform/v23/vertex");
+    const reposBase = "/platform/v23/repos";
+    this.repos = {
+      ...crudFactory(t, reposBase),
+      commit: (id, input) => t.request("POST", `${reposBase}/${id}/commits`, { json: input }),
+      commits: (id, branch) => t.request("GET", `${reposBase}/${id}/commits`, { params: { branch } }),
+      show: (id, commitId) => t.request("GET", `${reposBase}/${id}/commits/${commitId}`)
+    };
+    const objectSetsBase = "/platform/v23/object-sets";
+    this.objectSets = {
+      ...crudFactory(t, objectSetsBase),
+      materialize: (id, limit = 200) => t.request("POST", `${objectSetsBase}/${id}/materialize`, { json: { limit } })
+    };
+  }
+  t;
+  logic;
+  actions;
+  assist;
+  pipeline;
+  styles;
+  quiver;
+  connectors;
+  automate;
+  health;
+  contour;
+  vertex;
+  repos;
+  objectSets;
+  carbonValidate(config) {
+    return this.t.request("POST", "/platform/v23/carbon/validate", { json: config });
+  }
+  catalog() {
+    return this.t.request("GET", "/platform/v23");
+  }
+};
+var MarketplaceResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  storefront(opts = {}) {
+    return this.t.request("GET", "/platform/v23/marketplace", {
+      params: { sort: opts.sort ?? "popular", category: opts.category, search: opts.search, tags: opts.tags }
+    });
+  }
+  products(publishedOnly = false) {
+    return this.t.request("GET", "/platform/v23/marketplace/products", {
+      params: { published_only: publishedOnly }
+    });
+  }
+  create(input) {
+    return this.t.request("POST", "/platform/v23/marketplace/products", { json: input });
+  }
+  publish(pid) {
+    return this.t.request("POST", `/platform/v23/marketplace/products/${pid}/publish`);
+  }
+  details(pid) {
+    return this.t.request("GET", `/platform/v23/marketplace/${pid}`);
+  }
+  ontologyImpact(pid) {
+    return this.t.request("GET", `/platform/v23/marketplace/${pid}/ontology-impact`);
+  }
+  installPrecheck(pid) {
+    return this.t.request("GET", `/platform/v23/marketplace/${pid}/install-precheck`);
+  }
+  /** 422 with `{ok:false, gaps}` in the error payload when modules are missing. */
+  install(pid, opts = {}) {
+    return this.t.request("POST", `/platform/v23/marketplace/${pid}/install`, {
+      json: { confirm_text: opts.confirm_text ?? "instalar", config: opts.config, notes: opts.notes }
+    });
+  }
+  installed() {
+    return this.t.request("GET", "/platform/v23/marketplace/installed");
+  }
+  uninstall(installId) {
+    return this.t.request("POST", `/platform/v23/marketplace/installs/${installId}/uninstall`);
+  }
+  /** Admin, idempotent. */
+  seed() {
+    return this.t.request("POST", "/platform/v23/marketplace/seed");
+  }
+};
+var PlatformV24Resource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  createLogicFunction(input) {
+    return this.t.request("POST", "/platform/v24/logic/functions", { json: input });
+  }
+  listLogicFunctions() {
+    return this.t.request("GET", "/platform/v24/logic/functions");
+  }
+  invokeLogicFunction(fnId, inputs) {
+    return this.t.request("POST", `/platform/v24/logic/functions/${fnId}/invoke`, {
+      json: { inputs }
+    });
+  }
+  openAssistSession(surface, context) {
+    return this.t.request("POST", "/platform/v24/assist/sessions", {
+      json: { surface, context }
+    });
+  }
+  assistTurn(sessionId, content) {
+    return this.t.request("POST", `/platform/v24/assist/sessions/${sessionId}/turn`, {
+      json: { content }
+    });
+  }
+  createView(input) {
+    return this.t.request("POST", "/platform/v24/views", { json: input });
+  }
+  materializeView(viewId) {
+    return this.t.request("POST", `/platform/v24/views/${viewId}/materialize`);
+  }
+  listTemplates() {
+    return this.t.request("GET", "/platform/v24/marketplace/templates");
+  }
+  installTemplate(templateId, config) {
+    return this.t.request("POST", "/platform/v24/marketplace/install", {
+      json: { template_id: templateId, config }
+    });
+  }
+  createRule(input) {
+    return this.t.request("POST", "/platform/v24/rules", { json: input });
+  }
+  evaluateRules(trigger, subject) {
+    return this.t.request("POST", "/platform/v24/rules/evaluate", {
+      json: { trigger, subject }
+    });
+  }
+  recordCheckpoint(pipeline, step, opts = {}) {
+    return this.t.request("POST", "/platform/v24/checkpoints", {
+      json: { pipeline, step, status: opts.status ?? "OK", state: opts.state }
+    });
+  }
+  resumePipeline(pipeline) {
+    return this.t.request("GET", `/platform/v24/checkpoints/${pipeline}/resume`);
+  }
+  createExpectation(input) {
+    return this.t.request("POST", "/platform/v24/expectations", { json: input });
+  }
+  runExpectation(expId) {
+    return this.t.request("POST", `/platform/v24/expectations/${expId}/run`);
+  }
+  submitChangeRequest(input) {
+    return this.t.request("POST", "/platform/v24/change-requests", { json: input });
+  }
+  reviewChangeRequest(crId, status, note) {
+    return this.t.request("POST", `/platform/v24/change-requests/${crId}/review`, {
+      json: { status, note }
+    });
+  }
+  createScenario(input) {
+    return this.t.request("POST", "/platform/v24/scenarios", { json: input });
+  }
+  simulateScenario(scenarioId) {
+    return this.t.request("POST", `/platform/v24/scenarios/${scenarioId}/simulate`);
+  }
+  createNotebook(input) {
+    return this.t.request("POST", "/platform/v24/quiver/notebooks", { json: input });
+  }
+  createAgent(input) {
+    return this.t.request("POST", "/platform/v24/agent-studio/agents", { json: input });
+  }
+  createEvalDashboard(input) {
+    return this.t.request("POST", "/platform/v24/eval-dashboards", { json: input });
+  }
+  renderEvalDashboard(dashId) {
+    return this.t.request("GET", `/platform/v24/eval-dashboards/${dashId}/render`);
+  }
+  addVerticalTab(input) {
+    return this.t.request("POST", "/platform/v24/vertical-tabs", { json: input });
+  }
+  createAggregation(input) {
+    return this.t.request("POST", "/platform/v24/aggregations", { json: input });
+  }
+  runAggregation(aggId) {
+    return this.t.request("POST", `/platform/v24/aggregations/${aggId}/run`);
+  }
+  /** Multi-hop object-set traversal (gate `workshop.apps.read`). */
+  searchAround(input) {
+    return this.t.request("POST", "/workshop/object-set/search-around", { json: input });
+  }
+  /** On-the-fly aggregation: count/sum/avg/min/max/distinct_count/cardinality. */
+  aggregateObjectSet(input) {
+    return this.t.request("POST", "/workshop/object-set/aggregate", { json: input });
+  }
+  createOsdkToken(name, scopes) {
+    return this.t.request("POST", "/platform/v24/osdk-tokens", { json: { name, scopes } });
+  }
+  verifyOsdkToken(token) {
+    return this.t.request("POST", "/platform/v24/osdk-tokens/verify", { json: { token } });
+  }
+  createAutomation(input) {
+    return this.t.request("POST", "/platform/v24/automations", { json: input });
+  }
+  runAutomation(autoId) {
+    return this.t.request("POST", `/platform/v24/automations/${autoId}/run`);
+  }
+  computeOntologyMetrics() {
+    return this.t.request("POST", "/platform/v24/metrics/compute");
+  }
+  forkThread(parentSessionId, branchName, forkAtMessage = 0) {
+    return this.t.request("POST", "/platform/v24/thread-branches", {
+      json: {
+        parent_session_id: parentSessionId,
+        branch_name: branchName,
+        fork_at_message: forkAtMessage
+      }
+    });
+  }
+};
+var PlatformV25Resource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  // machinery
+  listProcesses() {
+    return this.t.request("GET", "/platform/v25/machinery/processes");
+  }
+  createProcess(input) {
+    return this.t.request("POST", "/platform/v25/machinery/processes", { json: input });
+  }
+  startProcessInstance(processId, opts = {}) {
+    return this.t.request("POST", `/platform/v25/machinery/processes/${processId}/instances`, {
+      json: opts
+    });
+  }
+  transitionProcessInstance(instanceId, to, reason) {
+    return this.t.request("POST", `/platform/v25/machinery/instances/${instanceId}/transition`, {
+      json: { to, reason }
+    });
+  }
+  // branch protection
+  setBranchProtection(dataset, branch, opts = {}) {
+    return this.t.request("PUT", `/platform/v25/branch-protection/${dataset}/${branch}`, {
+      json: {
+        require_approvals: opts.require_approvals ?? 1,
+        block_direct_commit: opts.block_direct_commit ?? true,
+        required_clearances: opts.required_clearances,
+        required_reviewers: opts.required_reviewers
+      }
+    });
+  }
+  evaluateBranchProtection(dataset, branch, opts = {}) {
+    return this.t.request("POST", "/platform/v25/branch-protection/evaluate", {
+      json: { dataset, branch, ...opts }
+    });
+  }
+  // kiosk
+  mintKioskSession(appId, opts = {}) {
+    return this.t.request("POST", "/platform/v25/kiosk/sessions", {
+      json: {
+        app_id: appId,
+        display_name: opts.display_name ?? "kiosk",
+        allowed_markings: opts.allowed_markings,
+        ttl_hours: opts.ttl_hours ?? 24
+      }
+    });
+  }
+  verifyKioskToken(token) {
+    return this.t.request("POST", "/platform/v25/kiosk/verify", { json: { token } });
+  }
+  // analyst threads
+  newAnalystThread(title = "Analyst thread") {
+    return this.t.request("POST", "/platform/v25/aip/analyst/threads", { json: { title } });
+  }
+  postAnalystMessage(threadId, input) {
+    return this.t.request("POST", `/platform/v25/aip/analyst/threads/${threadId}/messages`, {
+      json: input
+    });
+  }
+  // dataset ops
+  rollbackDataset(dataset, toAssetId, opts = {}) {
+    return this.t.request("POST", `/platform/v25/datasets/${dataset}/rollback`, {
+      json: { branch: opts.branch ?? "main", to_asset_id: toAssetId, reason: opts.reason ?? "" }
+    });
+  }
+  queueSnapshot(dataset, branch = "main") {
+    return this.t.request("POST", `/platform/v25/datasets/${dataset}/queue-snapshot`, {
+      json: { branch }
+    });
+  }
+  peekSnapshotQueue(dataset, branch = "main") {
+    return this.t.request("GET", `/platform/v25/datasets/${dataset}/queue-snapshot`, {
+      params: { branch }
+    });
+  }
+  setTransactionLimits(dataset, opts = {}) {
+    return this.t.request("PUT", `/platform/v25/datasets/${dataset}/transaction-limits`, {
+      json: { branch: "main", max_rows: 0, max_bytes: 0, max_open: 0, ...opts }
+    });
+  }
+  /** Repeated `dataset` query params. */
+  checkFreshness(datasets) {
+    return this.t.request("GET", "/platform/v25/workshop/widgets/data-freshness", {
+      params: { dataset: datasets }
+    });
+  }
+  // code scan
+  raiseCodeScanFinding(input) {
+    return this.t.request("POST", "/platform/v25/code-scan/findings", { json: input });
+  }
+  codeScanSummary(repoRef) {
+    return this.t.request("GET", `/platform/v25/code-scan/summary/${repoRef}`);
+  }
+  // evals
+  generateEvals(subjectFunction, opts = {}) {
+    return this.t.request("POST", "/platform/v25/evals/generate", {
+      json: {
+        subject_function: subjectFunction,
+        description: opts.description ?? "",
+        count: opts.count ?? 5
+      }
+    });
+  }
+  analyzeEvals(evalRunId, failures) {
+    return this.t.request("POST", "/platform/v25/evals/analyze", {
+      json: { eval_run_id: evalRunId, failures }
+    });
+  }
+};
+var PlatformV26Resource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  listPromotions() {
+    return this.t.request("GET", "/platform/v26/promotions");
+  }
+  promoteObjectType(objectType, opts = {}) {
+    return this.t.request("POST", "/platform/v26/promotions", {
+      json: { object_type: objectType, status: opts.status ?? "verified", justification: opts.justification }
+    });
+  }
+  listObjectViews(objectType) {
+    return this.t.request("GET", "/platform/v26/object-views", {
+      params: { object_type: objectType }
+    });
+  }
+  createObjectView(objectType, branch, opts = {}) {
+    return this.t.request("POST", "/platform/v26/object-views", {
+      json: {
+        object_type: objectType,
+        branch,
+        parent_branch: opts.parent_branch ?? "main",
+        view_spec: opts.view_spec
+      }
+    });
+  }
+  publishObjectView(branchId) {
+    return this.t.request("POST", `/platform/v26/object-views/${branchId}/publish`);
+  }
+  generateCoreView(objectType, topN = 8) {
+    return this.t.request("POST", `/platform/v26/core-views/generate/${objectType}`, {
+      params: { top_n: topN }
+    });
+  }
+  getCoreView(objectType) {
+    return this.t.request("GET", `/platform/v26/core-views/${objectType}`);
+  }
+  reserveCapacity(provider, model, opts = {}) {
+    return this.t.request("POST", "/platform/v26/capacity/reservations", {
+      json: { provider, model, reserved_tpm: 0, reserved_rpm: 0, ...opts }
+    });
+  }
+  consumeCapacity(provider, model, opts = {}) {
+    return this.t.request("POST", "/platform/v26/capacity/consume", {
+      json: { provider, model, tokens: opts.tokens ?? 0, requests: opts.requests ?? 1 }
+    });
+  }
+  /** Webhook listener — the secret is returned once. */
+  createListener(slug, opts = {}) {
+    return this.t.request("POST", "/platform/v26/listeners", {
+      json: { slug, integration: opts.integration ?? "generic", ...opts }
+    });
+  }
+  listenerEvents(listenerId) {
+    return this.t.request("GET", `/platform/v26/listeners/${listenerId}/events`);
+  }
+  /** mode ∈ report_only|hash|redact */
+  scanSensitive(payload, opts = {}) {
+    return this.t.request("POST", "/platform/v26/scanner/scan", {
+      json: { payload, mode: opts.mode ?? "report_only", scope: opts.scope ?? "inline", scope_ref: opts.scope_ref }
+    });
+  }
+  scanHistory(limit = 50) {
+    return this.t.request("GET", "/platform/v26/scanner/scans", { params: { limit } });
+  }
+  createMonitoringView(slug, displayName, opts = {}) {
+    return this.t.request("POST", "/platform/v26/monitoring", {
+      json: {
+        slug,
+        display_name: displayName,
+        project_scope: opts.project_scope,
+        resource_kinds: opts.resource_kinds ?? ["object_type", "action"]
+      }
+    });
+  }
+  monitoringRollup(slug) {
+    return this.t.request("GET", `/platform/v26/monitoring/${slug}/rollup`);
+  }
+  createHealthCheck(datasetName, name, checkType, spec) {
+    return this.t.request("POST", "/platform/v26/health/checks", {
+      json: { dataset_name: datasetName, name, check_type: checkType, spec }
+    });
+  }
+  runHealthCheck(checkId, branch = "main") {
+    return this.t.request("POST", `/platform/v26/health/checks/${checkId}/run`, {
+      params: { branch }
+    });
+  }
+  healthRuns(checkId, limit = 50) {
+    return this.t.request("GET", `/platform/v26/health/checks/${checkId}/runs`, {
+      params: { limit }
+    });
+  }
+  /** Hash-referenced version metadata — no binary body. */
+  uploadMediaVersion(mediaSet, path, input) {
+    return this.t.request("POST", "/platform/v26/media/upload", {
+      json: { media_set: mediaSet, path, size_bytes: 0, ...input }
+    });
+  }
+  mediaHistory(mediaSet, path) {
+    return this.t.request("GET", "/platform/v26/media/items/history", {
+      params: { media_set: mediaSet, path }
+    });
+  }
+  createInsight(slug, input) {
+    return this.t.request("POST", "/platform/v26/insight", { json: { slug, ...input } });
+  }
+  executeInsight(analysisId) {
+    return this.t.request("POST", `/platform/v26/insight/${analysisId}/execute`);
+  }
+  createPeer(slug, displayName, remoteUrl, authToken) {
+    return this.t.request("POST", "/platform/v26/peers", {
+      json: { slug, display_name: displayName, remote_url: remoteUrl, auth_token: authToken }
+    });
+  }
+  syncPeer(peerId, input) {
+    return this.t.request("POST", `/platform/v26/peers/${peerId}/sync`, { json: input });
+  }
+  listPeerMirrors(peerId) {
+    return this.t.request("GET", `/platform/v26/peers/${peerId}/mirrors`);
+  }
+  runHistory(opts = {}) {
+    return this.t.request("GET", "/platform/v26/run-history", {
+      params: { limit: 200, ...opts }
+    });
+  }
+};
+
+// src/client.ts
+var RETRIABLE_STATUS = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+function isRetriableError(err) {
+  if (err instanceof AegisAPIError) return RETRIABLE_STATUS.has(err.statusCode);
+  if (err instanceof TypeError) return true;
+  return err instanceof Error && err.name === "TimeoutError";
+}
+function backoffDelay(attempt, base, max) {
+  const exp = Math.min(max, base * 2 ** (attempt - 1));
+  return exp * (0.5 + Math.random() * 0.5);
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function envVar(name) {
+  if (typeof process !== "undefined" && process.env) return process.env[name];
+  return void 0;
+}
+var AegisClient = class {
+  baseUrl;
+  _token;
+  timeoutMs;
+  _fetchOverride;
+  _fetchInit;
+  _refreshToken;
+  _retry;
+  _refreshInFlight = null;
+  auth;
+  iam;
+  osdk;
+  operator;
+  ontology;
+  aip;
+  functions;
+  codeRepositories;
+  datasets;
+  // Reading / consumption
+  geo;
+  mapTemplates;
+  media;
+  docs;
+  pages;
+  dossier;
+  timeseries;
+  /** Public guest-token consumer surface (`/public/v1/guest/{token}/*`). */
+  publicGuest;
+  // Operational
+  alerts;
+  alarms;
+  events;
+  connectors;
+  pipelines;
+  chat;
+  notepad;
+  // Governance
+  lineage;
+  accessAudit;
+  markings;
+  resourceMarkings;
+  propertyMarkings;
+  rowPolicies;
+  erasure;
+  retention;
+  guestTokens;
+  // Domain
+  atlas;
+  briefing;
+  campaign;
+  cctv;
+  comunicados;
+  edge;
+  video;
+  // Collaboration / apps
+  appShell;
+  forms;
+  /** Alias of `iam.groups` (mirrors Python's standalone `client.groups`). */
+  groups;
+  organizations;
+  projects;
+  solutions;
+  spaces;
+  workspaces;
+  workspaceUpdates;
+  marketplace;
+  // Versioned platform surfaces
+  platformV22;
+  platformV23;
+  platformV24;
+  platformV25;
+  platformV26;
+  // Platform
+  workshop;
+  compute;
+  inference;
+  codegen;
+  correlation;
+  situational;
+  merge;
+  constructor(options = {}) {
+    const baseUrl = options.baseUrl ?? envVar("AEGIS_API_URL") ?? "http://localhost:8002";
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this._token = options.token ?? envVar("AEGIS_TOKEN") ?? null;
+    this.timeoutMs = options.timeoutMs ?? 15e3;
+    this._fetchOverride = options.fetch;
+    this._fetchInit = options.fetchInit ?? {};
+    this._refreshToken = options.refreshToken ?? null;
+    this._retry = {
+      retries: options.retry?.retries ?? 2,
+      baseDelayMs: options.retry?.baseDelayMs ?? 250,
+      maxDelayMs: options.retry?.maxDelayMs ?? 4e3,
+      retryPost: options.retry?.retryPost ?? false
+    };
+    this.auth = new AuthResource(this, (pair) => {
+      this.setToken(pair.access_token);
+      if (pair.refresh_token) this.setRefreshToken(pair.refresh_token);
+    });
+    this.iam = new IamResource(this);
+    this.osdk = new OsdkResource(this);
+    this.operator = new OperatorResource(this);
+    this.ontology = new OntologyResource(this);
+    this.aip = new AipResource(this);
+    this.functions = new FunctionsResource(this);
+    this.codeRepositories = new CodeRepositoriesResource(this);
+    this.datasets = new DatasetsResource(this);
+    this.geo = new GeoResource(this);
+    this.mapTemplates = new MapTemplatesResource(this);
+    this.media = new MediaResource(this);
+    this.docs = new DocsResource(this);
+    this.pages = new PagesResource(this);
+    this.dossier = new DossierResource(this);
+    this.timeseries = new TimeSeriesResource(this);
+    this.publicGuest = new PublicGuestResource(this);
+    this.alerts = new AlertsResource(this);
+    this.alarms = new AlarmsResource(this);
+    this.events = new EventsResource(this);
+    this.connectors = new ConnectorsResource(this);
+    this.pipelines = new PipelinesResource(this);
+    this.chat = new ChatResource(this);
+    this.notepad = new NotepadResource(this);
+    this.lineage = new LineageResource(this);
+    this.accessAudit = new AccessAuditResource(this);
+    this.markings = new MarkingsResource(this);
+    this.resourceMarkings = new ResourceMarkingsResource(this);
+    this.propertyMarkings = new PropertyMarkingsResource(this);
+    this.rowPolicies = new RowPoliciesResource(this);
+    this.erasure = new ErasureResource(this);
+    this.retention = new RetentionResource(this);
+    this.guestTokens = new GuestTokensResource(this);
+    this.atlas = new AtlasResource(this);
+    this.briefing = new BriefingResource(this);
+    this.campaign = new CampaignResource(this);
+    this.cctv = new CctvResource(this);
+    this.comunicados = new ComunicadosResource(this);
+    this.edge = new EdgeResource(this);
+    this.video = new VideoResource(this);
+    this.appShell = new AppShellResource(this);
+    this.forms = new FormsResource(this);
+    this.groups = this.iam.groups;
+    this.organizations = new OrganizationsResource(this);
+    this.projects = new ProjectsResource(this);
+    this.solutions = new SolutionsResource(this);
+    this.spaces = new SpacesResource(this);
+    this.workspaces = new WorkspacesResource(this);
+    this.workspaceUpdates = new WorkspaceUpdatesResource(this);
+    this.marketplace = new MarketplaceResource(this);
+    this.platformV22 = new PlatformV22Resource(this);
+    this.platformV23 = new PlatformV23Resource(this);
+    this.platformV24 = new PlatformV24Resource(this);
+    this.platformV25 = new PlatformV25Resource(this);
+    this.platformV26 = new PlatformV26Resource(this);
+    this.workshop = new WorkshopResource(this);
+    this.compute = new ComputeResource(this);
+    this.inference = new InferenceResource(this);
+    this.codegen = new CodegenResource(this);
+    this.correlation = new CorrelationResource(this);
+    this.situational = new SituationalResource(this);
+    this.merge = new MergeResource(this);
+  }
+  /** Replace the active bearer token (or clear with `null`). */
+  setToken(token) {
+    this._token = token;
+  }
+  /** Replace the refresh token used for automatic 401 recovery. */
+  setRefreshToken(token) {
+    this._refreshToken = token;
+  }
+  get token() {
+    return this._token;
+  }
+  get _fetch() {
+    if (this._fetchOverride) return this._fetchOverride;
+    const globalFetch = globalThis.fetch;
+    if (!globalFetch) {
+      throw new Error("no fetch available \u2014 Node >= 18, a browser, or pass options.fetch");
+    }
+    return globalFetch.bind(globalThis);
+  }
+  /** Generic escape hatch — call any AEGIS endpoint not yet wrapped.
+   *  Transient failures are retried with backoff (see `RetryOptions`);
+   *  a 401 triggers one transparent `POST /auth/refresh` + retry when a
+   *  refresh token is held. */
+  async request(method, path, opts = {}) {
+    try {
+      return await this._requestWithRetry(method, path, opts);
+    } catch (err) {
+      const refreshable = err instanceof AuthError && this._refreshToken !== null && !path.startsWith("/auth/");
+      if (!refreshable) throw err;
+      await this._refreshOnce();
+      return this._requestWithRetry(method, path, opts);
+    }
+  }
+  /** Rotate the refresh token (single-flight) and attach the new pair. */
+  _refreshOnce() {
+    this._refreshInFlight ??= (async () => {
+      try {
+        const pair = await this._requestWithRetry("POST", "/auth/refresh", {
+          json: { refresh_token: this._refreshToken }
+        });
+        this._token = pair.access_token;
+        this._refreshToken = pair.refresh_token ?? this._refreshToken;
+      } catch (err) {
+        if (err instanceof AuthError) this._refreshToken = null;
+        throw err;
+      } finally {
+        this._refreshInFlight = null;
+      }
+    })();
+    return this._refreshInFlight;
+  }
+  async _requestWithRetry(method, path, opts) {
+    const idempotent = method === "GET" || method === "HEAD" || this._retry.retryPost;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await this._doRequest(method, path, opts);
+      } catch (err) {
+        if (!idempotent || attempt >= this._retry.retries || !isRetriableError(err)) throw err;
+        await sleep(backoffDelay(attempt + 1, this._retry.baseDelayMs, this._retry.maxDelayMs));
+      }
+    }
+  }
+  async _doRequest(method, path, opts) {
+    const url = buildUrl(this.baseUrl, path, opts.params);
+    const headers = {};
+    if (this._token) headers.Authorization = `Bearer ${this._token}`;
+    const init = { ...this._fetchInit, method, headers };
+    if (opts.form !== void 0) {
+      init.body = opts.form;
+    } else if (opts.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(opts.json);
+    }
+    if (opts.signal) {
+      init.signal = opts.signal;
+    } else if (typeof AbortSignal !== "undefined" && "timeout" in AbortSignal) {
+      init.signal = AbortSignal.timeout(this.timeoutMs);
+    }
+    const res = await this._fetch(url, init);
+    return handleResponse(res);
+  }
+  /**
+   * Open a server-sent-events endpoint and iterate its events. Long-lived:
+   * no default timeout is applied — pass `signal` to cancel.
+   *
+   * ```ts
+   * for await (const ev of client.stream("/operator/tasks/t1/events")) { … }
+   * ```
+   */
+  async *stream(path, opts = {}) {
+    const url = buildUrl(this.baseUrl, path, opts.params);
+    const headers = { Accept: "text/event-stream" };
+    if (this._token) headers.Authorization = `Bearer ${this._token}`;
+    const init = { ...this._fetchInit, method: opts.method ?? "GET", headers };
+    if (opts.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(opts.json);
+      init.method = opts.method ?? "POST";
+    }
+    if (opts.signal) init.signal = opts.signal;
+    const res = await this._fetch(url, init);
+    if (!res.ok || !res.body) {
+      await handleResponse(res);
+      throw new AegisAPIError(res.status, "stream endpoint returned no body");
+    }
+    yield* parseSseStream(res.body);
+  }
+};
+
+// src/cli-core.ts
+var CliUsageError = class extends Error {
+};
+var USAGE = `aegis-osdk \u2014 typed OSDK codegen from a live AEGIS ontology
+
+Usage:
+  aegis-osdk generate [--lang typescript|python] [--out <file>]
+                      [--base-url <url>] [--token <token>]
+  aegis-osdk manifest [--base-url <url>] [--token <token>]
+
+Auth/URL resolution: --base-url/--token flags, else AEGIS_API_URL/AEGIS_TOKEN env.
+
+Commands:
+  generate   Fetch GET /ontology/osdk/generate and write the typed module
+             (default --lang typescript, default --out = server filename,
+             e.g. ./aegis_osdk.ts). Prints the contract version.
+  manifest   Print the ontology OSDK manifest (JSON) to stdout.
+`;
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    return { command: "help", lang: "typescript" };
+  }
+  if (command !== "generate" && command !== "manifest") {
+    throw new CliUsageError(`unknown command: ${command}
+
+${USAGE}`);
+  }
+  const opts = { command, lang: "typescript" };
+  for (let i = 0; i < rest.length; i++) {
+    const flag = rest[i];
+    const value = rest[i + 1];
+    const need = () => {
+      if (value === void 0 || value.startsWith("--")) {
+        throw new CliUsageError(`missing value for ${flag}`);
+      }
+      i++;
+      return value;
+    };
+    switch (flag) {
+      case "--lang":
+        opts.lang = need();
+        break;
+      case "--out":
+        opts.out = need();
+        break;
+      case "--base-url":
+        opts.baseUrl = need();
+        break;
+      case "--token":
+        opts.token = need();
+        break;
+      default:
+        throw new CliUsageError(`unknown flag: ${flag}
+
+${USAGE}`);
+    }
+  }
+  return opts;
+}
+async function run(opts, io) {
+  if (opts.command === "help") {
+    io.log(USAGE);
+    return 0;
+  }
+  const client = new AegisClient({
+    baseUrl: opts.baseUrl,
+    token: opts.token,
+    ...io.fetch ? { fetch: io.fetch } : {}
+  });
+  if (opts.command === "manifest") {
+    const manifest = await client.ontology.osdkManifest();
+    io.log(JSON.stringify(manifest, null, 2));
+    return 0;
+  }
+  const payload = await client.ontology.osdkGenerate(opts.lang);
+  const outPath = opts.out ?? `./${payload.filename}`;
+  await io.writeFile(outPath, payload.source);
+  io.log(
+    `wrote ${outPath} (lang=${payload.lang}` + (payload.contract_version ? `, contract=${payload.contract_version}` : "") + `)`
+  );
+  return 0;
+}
+
+// src/cli.ts
+async function main() {
+  try {
+    const opts = parseArgs(process.argv.slice(2));
+    const code = await run(opts, {
+      writeFile: (path, content) => writeFile(path, content, "utf8"),
+      log: (line) => console.log(line)
+    });
+    process.exitCode = code;
+  } catch (err) {
+    if (err instanceof CliUsageError) {
+      console.error(err.message);
+      process.exitCode = 2;
+    } else if (err instanceof AegisAPIError) {
+      console.error(`AEGIS API error ${err.statusCode}: ${err.detail}`);
+      process.exitCode = 1;
+    } else {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+    }
+  }
+}
+void main();
+//# sourceMappingURL=cli.js.map