aegis-platform-sdk 0.1.0 → 1.3.0

package/dist/index.js

@@ -20,10 +20,27 @@ var NotFoundError = class extends AegisAPIError {
 
 // src/transport.ts
 function buildUrl(baseUrl, path, params) {
-  const url = new URL(baseUrl.replace(/\/+$/, "") + path);
+  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) url.searchParams.set(key, String(value));
+      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();
@@ -49,19 +66,96 @@ async function handleResponse(res) {
   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, setToken) {
+  constructor(t, attach) {
     this.t = t;
-    this.setToken = setToken;
+    this.attach = attach;
   }
   t;
-  setToken;
+  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.setToken(pair.access_token);
+    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() {
@@ -617,72 +711,3822 @@ var DatasetsResource = class {
   }
 };
 
-// src/client.ts
-function envVar(name) {
-  if (typeof process !== "undefined" && process.env) return process.env[name];
-  return void 0;
-}
-var AegisClient = class {
-  baseUrl;
-  _token;
-  timeoutMs;
-  _fetch;
-  auth;
-  iam;
-  osdk;
-  operator;
-  ontology;
-  aip;
-  functions;
-  codeRepositories;
-  datasets;
-  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._fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.auth = new AuthResource(this, (t) => this.setToken(t));
-    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);
+// src/resources/reading.ts
+var GeoResource = class {
+  constructor(t) {
+    this.t = t;
   }
-  /** Replace the active bearer token (or clear with `null`). */
-  setToken(token) {
-    this._token = token;
+  t;
+  nodes(opts = {}) {
+    return this.t.request("GET", "/api/v1/geo/nodes", { params: opts });
   }
-  get token() {
-    return this._token;
+  nodeTypes() {
+    return this.t.request("GET", "/api/v1/geo/node-types");
   }
-  /** Generic escape hatch — call any AEGIS endpoint not yet wrapped. */
-  async request(method, path, opts = {}) {
-    const url = buildUrl(this.baseUrl, path, opts.params);
-    const headers = {};
-    if (this._token) headers.Authorization = `Bearer ${this._token}`;
-    const init = { method, headers };
-    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);
+  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");
     }
-    const res = await this._fetch(url, init);
-    return handleResponse(res);
+    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 VALID_PROJECT_ROLES = [
+  "owner",
+  "editor",
+  "reviewer",
+  "viewer",
+  "discoverer"
+];
+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/classification.ts
+var VALID_LEVELS = [
+  "PUBLICO",
+  "INTERNO",
+  "RESTRITO",
+  "SECRETO"
+];
+var CLASSIFICATION_RANK = {
+  PUBLICO: 0,
+  INTERNO: 1,
+  RESTRITO: 2,
+  SECRETO: 3
+};
+var CLASSIFICATION_LABEL = {
+  PUBLICO: "P\xFAblico",
+  INTERNO: "Interno",
+  RESTRITO: "Restrito",
+  SECRETO: "Secreto"
+};
+var ClassificationInvariantViolation = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ClassificationInvariantViolation";
+  }
+};
+function rank(level) {
+  const r = CLASSIFICATION_RANK[level];
+  if (r === void 0) throw new ClassificationInvariantViolation(`invalid level: ${level}`);
+  return r;
+}
+function maxLevel(levels) {
+  let best = "PUBLICO";
+  for (const level of levels) {
+    if (rank(level) > CLASSIFICATION_RANK[best]) best = level;
+  }
+  return best;
+}
+function validateInvariant(fileCls, dataCls, upstreamData = []) {
+  if (rank(fileCls) < rank(dataCls)) {
+    throw new ClassificationInvariantViolation(
+      `file classification ${fileCls} must dominate data classification ${dataCls}`
+    );
+  }
+  for (const upstream of upstreamData) {
+    if (rank(dataCls) < rank(upstream)) {
+      throw new ClassificationInvariantViolation(
+        `data classification ${dataCls} must dominate upstream ${upstream}`
+      );
+    }
+  }
+}
+
+// src/permissions.ts
+var NAV_PERMISSIONS = [
+  "nav.section.discover",
+  "nav.item.discover.home",
+  "nav.section.operations",
+  "nav.item.operations.tasks",
+  "nav.section.core_loop",
+  "nav.item.core_loop.alerts",
+  "nav.item.core_loop.proposals",
+  "nav.item.core_loop.actions",
+  "nav.section.ontology",
+  "nav.item.ontology.manager",
+  "nav.item.ontology.explorer",
+  "nav.item.ontology.types",
+  "nav.item.ontology.actions",
+  "nav.item.ontology.interfaces",
+  "nav.item.ontology.links",
+  "nav.item.ontology.views",
+  "nav.item.ontology.aggregations",
+  "nav.item.ontology.object_sets",
+  "nav.section.data",
+  "nav.item.data.datasets",
+  "nav.item.data.pipelines",
+  "nav.item.data.connectors",
+  "nav.item.data.media",
+  "nav.item.data.schedules",
+  "nav.item.data.notepad",
+  "nav.item.data.lineage",
+  "nav.item.data.health",
+  "nav.section.aip",
+  "nav.item.aip.threads",
+  "nav.item.aip.agents",
+  "nav.item.aip.tools",
+  "nav.item.aip.logic",
+  "nav.item.aip.models",
+  "nav.item.aip.capacity",
+  "nav.item.aip.scenarios",
+  "nav.item.aip.evals",
+  "nav.item.aip.memory",
+  "nav.item.aip.mcp_adapters",
+  "nav.section.workshop",
+  "nav.item.workshop.apps",
+  "nav.section.governance",
+  "nav.item.governance.projects",
+  "nav.item.governance.audit",
+  "nav.item.governance.lgpd",
+  "nav.item.governance.trace",
+  "nav.item.governance.rules",
+  "nav.item.governance.change_requests",
+  "nav.item.governance.automations",
+  "nav.item.governance.tokens",
+  "nav.item.governance.peers",
+  "nav.item.governance.code_scan",
+  "nav.item.governance.kiosk",
+  "nav.item.governance.access",
+  "nav.item.governance.osdk",
+  "nav.section.resources",
+  "nav.item.resources.docs",
+  "nav.item.resources.template_gallery",
+  "nav.item.resources.aegis_sdk",
+  "nav.section.other",
+  "nav.item.other.intel_map",
+  "nav.item.other.cognitive",
+  "nav.item.other.map_view",
+  "nav.section.campanha",
+  "nav.item.campaign.hub",
+  "nav.item.campaign.chat",
+  "nav.item.campaign.visibility",
+  "nav.item.campaign.agents",
+  "nav.item.campaign.scenarios",
+  "nav.item.campaign.brief",
+  "nav.section.painel-de-controle",
+  "nav.item.painel.home",
+  "nav.item.painel.aprovacoes",
+  "nav.item.painel.comunicacoes",
+  "nav.item.painel.atividade"
+];
+var CAPABILITY_PERMISSIONS = [
+  "ontology.types.read",
+  "ontology.types.write",
+  "ontology.actions.read",
+  "ontology.actions.write",
+  "ontology.actions.execute",
+  "ontology.actions.execute_external",
+  "ontology.objects.read",
+  "ontology.objects.write",
+  "ontology.objects.bulk_delete",
+  "ontology.links.read",
+  "ontology.links.write",
+  "solution.diagram.read",
+  "solution.diagram.write",
+  "solution.diagram.publish",
+  "solution.diagram.delete",
+  "solution.diagram.history.read",
+  "solution.materialize.delete",
+  "solution.refactor",
+  "data.datasets.read",
+  "data.datasets.write",
+  "data.pipelines.read",
+  "data.pipelines.write",
+  "data.lineage.read",
+  "data.connectors.read",
+  "data.connectors.write",
+  "aip.threads.read",
+  "aip.threads.write",
+  "aip.agents.read",
+  "aip.agents.write",
+  "aip.models.read",
+  "aip.models.write",
+  "aip.evals.read",
+  "aip.evals.run",
+  "aip.memory.read",
+  "aip.memory.write",
+  "workshop.apps.read",
+  "workshop.apps.write",
+  "workshop.apps.purge",
+  "operator.tasks.read",
+  "operator.tasks.write",
+  "governance.audit.read",
+  "governance.rules.read",
+  "governance.rules.write",
+  "governance.change_requests.read",
+  "governance.change_requests.write",
+  "governance.change_requests.approve",
+  "governance.tokens.read",
+  "governance.tokens.write",
+  "governance.lgpd.read",
+  "governance.lgpd.write",
+  "governance.peers.read",
+  "governance.peers.write",
+  "governance.kiosk.read",
+  "governance.kiosk.write",
+  "admin.acessos",
+  "admin.classificacao",
+  "admin.auditoria",
+  "admin.federacao",
+  "admin.unidades",
+  "admin.templates",
+  "admin.automacoes",
+  "admin.tokens",
+  "campaign.chat.read",
+  "campaign.chat.write",
+  "campaign.brief.read",
+  "campaign.brief.generate",
+  "campaign.brief.sign",
+  "campaign.scenario.read",
+  "campaign.scenario.run",
+  "campaign.scenario.write",
+  "campaign.visibility.read",
+  "campaign.visibility.pin",
+  "campaign.visibility.escalate",
+  "campaign.agents.read",
+  "campaign.agents.write",
+  "campaign.agents.run",
+  "campaign.flows.read",
+  "campaign.flows.write",
+  "campaign.flows.run",
+  "campaign.briefing.read",
+  "campaign.briefing.refresh",
+  "campaign.briefing.headline",
+  "campaign.briefing.crisis_override",
+  "vault.cookies.manage",
+  "iam.users.read",
+  "iam.users.write",
+  "iam.roles.read",
+  "iam.roles.write",
+  "iam.permissions.read",
+  "iam.permissions.write",
+  "iam.nav.read",
+  "iam.nav.write",
+  "iam.audit.read",
+  "iam.groups.read",
+  "iam.groups.write",
+  "iam.groups.manage_members",
+  "docs.tree.read",
+  "docs.content.read",
+  "aip.flows.read",
+  "aip.flows.write",
+  "aip.flows.execute",
+  "aip.agents.execute",
+  "briefing.read",
+  "briefing.refresh",
+  "ontology.objects.view",
+  "ontology.graph.read",
+  "ontology.graph.export",
+  "ontology.explorer.aggregate",
+  "workshop.briefings.read",
+  "workshop.briefings.write",
+  "workshop.briefings.broadcast",
+  "workshop.dossiers.read",
+  "workshop.dossiers.write",
+  "workshop.dossiers.share",
+  "workshop.covs.read",
+  "workshop.covs.write",
+  "workshop.covs.share",
+  "chat.channels.read",
+  "chat.channels.write",
+  "chat.channels.manage",
+  "chat.messages.send",
+  "chat.messages.read",
+  "alerts.feeds.read",
+  "alerts.feeds.subscribe",
+  "alerts.watches.read",
+  "alerts.watches.subscribe",
+  "alerts.geofences.read",
+  "alerts.geofences.manage",
+  "alerts.shares.read",
+  "alerts.read",
+  "alerts.escalate",
+  "alerts.routes.view",
+  "alerts.routes.manage",
+  "atlas.layers.read",
+  "atlas.layers.manage",
+  "atlas.geofences.draw",
+  "atlas.evaluation.read",
+  "atlas.evaluation.manage",
+  "video.exports.create",
+  "connectors.manage",
+  "events.pipeline.view",
+  "events.pipeline.manage",
+  "situational.correlate.view",
+  "situational.correlate.manage",
+  "security.painel.view",
+  "security.buscar.view",
+  "security.geo.view",
+  "security.geo.cerca.create",
+  "security.cameras.view",
+  "security.cameras.tag",
+  "security.cameras.export",
+  "security.cameras.manage",
+  "security.cameras.bookmark",
+  "security.cameras.hotlist",
+  "security.cameras.cloud_inference",
+  "security.explorador.view",
+  "security.rede.view",
+  "security.rede.edit",
+  "security.ficha.view",
+  "security.ficha.edit",
+  "security.alertas.view",
+  "security.alertas.resolve",
+  "security.relatorios.view",
+  "security.relatorios.edit",
+  "security.relatorios.close",
+  "security.briefings.view",
+  "security.briefings.edit",
+  "security.briefings.broadcast",
+  "security.workshop.view",
+  "security.workshop.edit",
+  "security.workshop.publish_global",
+  "security.fluxos.view",
+  "security.fluxos.edit",
+  "security.fluxos.run",
+  "security.agentes.view",
+  "security.agentes.edit",
+  "security.agentes.run",
+  "security.ontologia.view",
+  "security.ontologia.edit",
+  "security.workshop.kiosk",
+  "security.configuracoes.view",
+  "security.browser.manage",
+  "painel.home.view",
+  "painel.aprovacoes.view",
+  "painel.aprovacoes.act",
+  "painel.comunicacoes.view",
+  "painel.comunicacoes.edit",
+  "painel.atividade.view",
+  "painel.atividade.export",
+  "painel.favoritos.edit",
+  "organization.read",
+  "organization.write",
+  "organization.invite_guest",
+  "space.read",
+  "space.write",
+  "space.add_organization",
+  "project.read",
+  "project.write",
+  "project.move",
+  "project.link",
+  "markings.read",
+  "markings.write",
+  "markings.apply",
+  "markings.remove",
+  "markings.expand_access",
+  "markings.manage_eligibility",
+  "classification.read",
+  "classification.set",
+  "classification.upgrade",
+  "project.constraints.read",
+  "project.constraints.configure",
+  "project.constraints.revalidate",
+  "workspace.read",
+  "workspace.write",
+  "workspace.delete",
+  "workspace.publish",
+  "workspace.history.read",
+  "workspace.republish",
+  "workspace.update.read",
+  "workspace.update.write",
+  "workspace.update.archive",
+  "workspace.update.delete",
+  "workspace.update.view",
+  "workspace.navigation.read",
+  "workspace.navigation.configure",
+  "workspace.promote.read",
+  "workspace.promote.set",
+  "workspace.promote.unset",
+  "workspace.kiosk.read",
+  "workspace.kiosk.configure",
+  "workspace.kiosk.session.start",
+  "workspace.kiosk.session.end",
+  "app_shell.manage",
+  "comunicado.read",
+  "comunicado.write",
+  "comunicado.delete",
+  "forms.submit",
+  "forms.submissions.read",
+  "vendor.dev_mode",
+  "public.token.read",
+  "public.token.issue",
+  "public.token.revoke",
+  "messaging.send",
+  "automation.alarms.read",
+  "automation.alarms.write",
+  "data.media.read",
+  "data.media.write",
+  "function.read",
+  "function.write",
+  "function.invoke",
+  "function.review",
+  "sandbox.install",
+  "sandbox.terminal",
+  "llm.budget.read",
+  "llm.budget.write",
+  "governance.retention.read",
+  "governance.retention.write",
+  "rowpolicy.read",
+  "rowpolicy.write",
+  "compute.providers.read",
+  "compute.providers.write",
+  "compute.pipelines.deploy",
+  "vision.count.execute",
+  "ontology.objects.bulk_write"
+];
+var ALL_PERMISSIONS = [
+  ...NAV_PERMISSIONS,
+  ...CAPABILITY_PERMISSIONS
+];
+function toDef(key, kind) {
+  const idx = key.lastIndexOf(".");
+  return { key, kind, resource: key.slice(0, idx), action: key.slice(idx + 1) };
+}
+function listPermissions(kind) {
+  if (kind === "nav") return NAV_PERMISSIONS.map((k) => toDef(k, "nav"));
+  if (kind === "capability") return CAPABILITY_PERMISSIONS.map((k) => toDef(k, "capability"));
+  if (kind !== void 0) throw new Error(`invalid permission kind: ${String(kind)}`);
+  return [...listPermissions("nav"), ...listPermissions("capability")];
+}
+var ALL_SET = new Set(ALL_PERMISSIONS);
+function isSystemPermission(key) {
+  return ALL_SET.has(key);
+}
+
+// src/osdk-applications.ts
+var APPLICATIONS = [
+  {
+    slug: "security-app",
+    display_name: "Security Application",
+    description: "Operational security frontend \u2014 painel, geo, cameras, ficha, workshop, AIP.",
+    permissions: [
+      "nav.section.discover",
+      "nav.section.painel-de-controle",
+      "nav.item.painel.home",
+      "nav.item.painel.aprovacoes",
+      "nav.item.painel.comunicacoes",
+      "nav.item.painel.atividade",
+      "security.painel.view",
+      "security.buscar.view",
+      "security.geo.view",
+      "security.geo.cerca.create",
+      "security.cameras.view",
+      "security.cameras.tag",
+      "security.cameras.export",
+      "security.cameras.manage",
+      "security.cameras.bookmark",
+      "security.cameras.hotlist",
+      "security.cameras.cloud_inference",
+      "video.exports.create",
+      "security.explorador.view",
+      "security.rede.view",
+      "security.rede.edit",
+      "security.ficha.view",
+      "security.ficha.edit",
+      "security.alertas.view",
+      "security.alertas.resolve",
+      "security.relatorios.view",
+      "security.relatorios.edit",
+      "security.relatorios.close",
+      "security.briefings.view",
+      "security.briefings.edit",
+      "security.briefings.broadcast",
+      "security.workshop.view",
+      "security.workshop.edit",
+      "security.workshop.publish_global",
+      "security.fluxos.view",
+      "security.fluxos.edit",
+      "security.fluxos.run",
+      "security.agentes.view",
+      "security.agentes.edit",
+      "security.agentes.run",
+      "security.ontologia.view",
+      "security.ontologia.edit",
+      "security.workshop.kiosk",
+      "security.configuracoes.view",
+      "security.browser.manage",
+      "connectors.manage",
+      "events.pipeline.view",
+      "events.pipeline.manage",
+      "alerts.read",
+      "alerts.escalate",
+      "alerts.geofences.read",
+      "alerts.geofences.manage",
+      "alerts.routes.view",
+      "alerts.routes.manage",
+      "situational.correlate.view",
+      "situational.correlate.manage",
+      "painel.home.view",
+      "painel.aprovacoes.view",
+      "painel.aprovacoes.act",
+      "painel.comunicacoes.view",
+      "painel.comunicacoes.edit",
+      "painel.atividade.view",
+      "painel.atividade.export",
+      "painel.favoritos.edit",
+      "aip.threads.read",
+      "aip.threads.write",
+      "aip.models.read",
+      "aip.memory.read",
+      "aip.memory.write",
+      "compute.providers.read",
+      "compute.providers.write",
+      "compute.pipelines.deploy",
+      "vision.count.execute",
+      "ontology.objects.bulk_write"
+    ]
+  },
+  {
+    slug: "aip-application",
+    display_name: "AIP Application",
+    description: "AIP threads, agents, tools, logic, models, evals, memory.",
+    permissions: [
+      "nav.section.aip",
+      "nav.item.aip.threads",
+      "nav.item.aip.agents",
+      "nav.item.aip.tools",
+      "nav.item.aip.logic",
+      "nav.item.aip.models",
+      "nav.item.aip.capacity",
+      "nav.item.aip.scenarios",
+      "nav.item.aip.evals",
+      "nav.item.aip.memory",
+      "nav.item.aip.mcp_adapters",
+      "aip.threads.read",
+      "aip.threads.write",
+      "aip.agents.read",
+      "aip.agents.write",
+      "aip.agents.execute",
+      "aip.models.read",
+      "aip.models.write",
+      "aip.memory.read",
+      "aip.memory.write",
+      "aip.evals.read",
+      "aip.evals.run",
+      "aip.flows.read",
+      "aip.flows.write",
+      "aip.flows.execute"
+    ]
+  },
+  {
+    slug: "ontology-application",
+    display_name: "Ontology Application",
+    description: "Ontology types, objects, links, graph, solution diagrams, lineage.",
+    permissions: [
+      "ontology.types.read",
+      "ontology.types.write",
+      "ontology.actions.read",
+      "ontology.actions.write",
+      "ontology.actions.execute",
+      "ontology.actions.execute_external",
+      "ontology.objects.read",
+      "ontology.objects.write",
+      "ontology.objects.view",
+      "ontology.links.read",
+      "ontology.links.write",
+      "ontology.graph.read",
+      "ontology.graph.export",
+      "ontology.explorer.aggregate",
+      "data.lineage.read",
+      "solution.diagram.read",
+      "solution.diagram.write",
+      "solution.diagram.publish",
+      "solution.diagram.delete",
+      "solution.diagram.history.read",
+      "solution.materialize.delete",
+      "solution.refactor",
+      "messaging.send",
+      "compute.providers.read",
+      "compute.pipelines.deploy",
+      "vision.count.execute",
+      "ontology.objects.bulk_write"
+    ]
+  },
+  {
+    slug: "governance-application",
+    display_name: "Governance Application",
+    description: "IAM groups, audit, rules, change requests, tokens, LGPD, markings, classification.",
+    permissions: [
+      "iam.groups.read",
+      "iam.groups.write",
+      "iam.groups.manage_members",
+      "governance.audit.read",
+      "governance.rules.read",
+      "governance.rules.write",
+      "governance.change_requests.read",
+      "governance.change_requests.write",
+      "governance.change_requests.approve",
+      "governance.tokens.read",
+      "governance.tokens.write",
+      "governance.lgpd.read",
+      "governance.lgpd.write",
+      "governance.peers.read",
+      "governance.peers.write",
+      "governance.kiosk.read",
+      "governance.kiosk.write",
+      "admin.acessos",
+      "admin.classificacao",
+      "admin.auditoria",
+      "admin.federacao",
+      "admin.unidades",
+      "admin.templates",
+      "admin.automacoes",
+      "admin.tokens",
+      "markings.read",
+      "markings.write",
+      "markings.apply",
+      "markings.remove",
+      "markings.expand_access",
+      "markings.manage_eligibility",
+      "classification.read",
+      "classification.set",
+      "classification.upgrade",
+      "project.constraints.read",
+      "project.constraints.configure",
+      "project.constraints.revalidate",
+      "public.token.read",
+      "public.token.issue",
+      "public.token.revoke"
+    ]
+  },
+  {
+    slug: "workshop-application",
+    display_name: "Workshop Application",
+    description: "Workshop apps, briefings, dossiers, COVs, workspaces, app-shell, comunicados.",
+    permissions: [
+      "workshop.apps.read",
+      "workshop.apps.write",
+      "workshop.briefings.read",
+      "workshop.briefings.write",
+      "workshop.briefings.broadcast",
+      "workshop.dossiers.read",
+      "workshop.dossiers.write",
+      "workshop.dossiers.share",
+      "workshop.covs.read",
+      "workshop.covs.write",
+      "workshop.covs.share",
+      "workspace.read",
+      "workspace.write",
+      "workspace.delete",
+      "workspace.publish",
+      "workspace.history.read",
+      "workspace.republish",
+      "workspace.update.read",
+      "workspace.update.write",
+      "workspace.update.archive",
+      "workspace.update.delete",
+      "workspace.update.view",
+      "workspace.navigation.read",
+      "workspace.navigation.configure",
+      "workspace.promote.read",
+      "workspace.promote.set",
+      "workspace.promote.unset",
+      "workspace.kiosk.read",
+      "workspace.kiosk.configure",
+      "workspace.kiosk.session.start",
+      "workspace.kiosk.session.end",
+      "app_shell.manage",
+      "comunicado.read",
+      "comunicado.write",
+      "comunicado.delete"
+    ]
+  },
+  {
+    slug: "campaign-application",
+    display_name: "Campaign Application (politicians-app)",
+    description: "Campaign hub, chat, visibility, agents, scenarios, briefing.",
+    permissions: [
+      "nav.section.campanha",
+      "nav.item.campaign.hub",
+      "nav.item.campaign.chat",
+      "nav.item.campaign.visibility",
+      "nav.item.campaign.agents",
+      "nav.item.campaign.scenarios",
+      "nav.item.campaign.brief",
+      "campaign.chat.read",
+      "campaign.chat.write",
+      "campaign.brief.read",
+      "campaign.brief.generate",
+      "campaign.brief.sign",
+      "campaign.scenario.read",
+      "campaign.scenario.run",
+      "campaign.scenario.write",
+      "campaign.visibility.read",
+      "campaign.visibility.pin",
+      "campaign.visibility.escalate",
+      "campaign.agents.read",
+      "campaign.agents.write",
+      "campaign.agents.run",
+      "campaign.briefing.read",
+      "campaign.briefing.refresh",
+      "campaign.briefing.headline",
+      "campaign.briefing.crisis_override",
+      "vault.cookies.manage"
+    ]
+  },
+  {
+    slug: "docs-loader",
+    display_name: "Docs UI Loader",
+    description: "Read-only access to the docs tree and content.",
+    permissions: ["docs.tree.read", "docs.content.read"]
+  }
+];
+function listApplications() {
+  return APPLICATIONS;
+}
+function applicationBySlug(slug) {
+  return APPLICATIONS.find((app) => app.slug === slug);
+}
+function applicationHas(app, key) {
+  return app.permissions.includes(key);
+}
+function validateApplication(app) {
+  for (const key of app.permissions) {
+    if (!isSystemPermission(key)) {
+      throw new Error(`application ${app.slug} references unknown permission: ${key}`);
+    }
+  }
+}
+
+// src/osdk-adapter.ts
+function asOsdkClient(client) {
+  return {
+    get: (path, params) => client.request("GET", path, {
+      params
+    }),
+    post: (path, body) => client.request("POST", path, { json: body ?? {} })
+  };
+}
 export {
+  ALL_PERMISSIONS,
+  APPLICATIONS,
+  AccessAuditResource,
   AegisAPIError,
   AegisClient,
+  AipResource,
+  AlarmsResource,
+  AlertsResource,
+  AppShellResource,
+  AtlasResource,
   AuthError,
+  AuthResource,
+  BriefingResource,
+  CAPABILITY_PERMISSIONS,
+  CLASSIFICATION_LABEL,
+  CLASSIFICATION_RANK,
+  CampaignResource,
+  CctvResource,
+  ChatResource,
+  ClassificationInvariantViolation,
+  CodeRepositoriesResource,
+  CodegenResource,
+  ComputeControlResource,
+  ComputeResource,
+  ComunicadosResource,
+  ConnectorsResource,
+  CorrelationResource,
+  DatasetsResource,
+  DocsResource,
+  DossierResource,
+  EdgeResource,
+  ErasureResource,
+  EventsResource,
+  FormsResource,
+  FunctionsResource,
+  GeoResource,
+  GroupsResource,
+  GuestTokensResource,
+  IamResource,
+  InferenceResource,
+  LineageResource,
+  MapTemplatesResource,
+  MarketplaceResource,
+  MarkingsResource,
+  MediaResource,
+  MergeResource,
+  NAV_PERMISSIONS,
   NotFoundError,
-  PermissionDeniedError
+  NotepadResource,
+  OntologyResource,
+  OperatorResource,
+  OrganizationsResource,
+  OsdkResource,
+  PagesResource,
+  PermissionDeniedError,
+  PipelinesResource,
+  PlatformV22Resource,
+  PlatformV23Resource,
+  PlatformV24Resource,
+  PlatformV25Resource,
+  PlatformV26Resource,
+  ProjectsResource,
+  PropertyMarkingsResource,
+  PublicGuestResource,
+  ResourceMarkingsResource,
+  RetentionResource,
+  RowPoliciesResource,
+  SituationalResource,
+  SolutionsResource,
+  SpacesResource,
+  TimeSeriesResource,
+  VALID_LEVELS,
+  VALID_PROJECT_ROLES,
+  VideoResource,
+  WorkshopResource,
+  WorkspaceUpdatesResource,
+  WorkspacesResource,
+  applicationBySlug,
+  applicationHas,
+  asOsdkClient,
+  isSystemPermission,
+  listApplications,
+  listPermissions,
+  maxLevel,
+  parseSseStream,
+  validateApplication,
+  validateInvariant
 };
 //# sourceMappingURL=index.js.map