@terrantula/sdk 0.0.1

package/dist/local.js

@@ -0,0 +1,1549 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/local.ts
+var local_exports = {};
+__export(local_exports, {
+  createLocalClient: () => createLocalClient
+});
+module.exports = __toCommonJS(local_exports);
+
+// src/index.ts
+var import_client4 = require("hono/client");
+var import_hono = require("hono");
+
+// src/helpers.ts
+function fallbackMessage(status) {
+  return `Request failed with status ${status}`;
+}
+var TerrantulaError = class extends Error {
+  constructor(status, body) {
+    const message = body != null && typeof body === "object" && "error" in body ? String(body.error) : fallbackMessage(status);
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "TerrantulaError";
+  }
+  status;
+  body;
+};
+function withSchema(schema, fn) {
+  return Object.assign(fn, { schema });
+}
+async function call(p) {
+  const res = await p;
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) throw new TerrantulaError(res.status, body);
+  return body;
+}
+var buildHeaders = (token) => {
+  if (!token) return {};
+  if (typeof token === "function")
+    return async () => ({ Authorization: `Bearer ${await token()}` });
+  return { Authorization: `Bearer ${token}` };
+};
+function stringifyQuery(params) {
+  return Object.fromEntries(
+    Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => [k, String(v)])
+  );
+}
+
+// src/orgs.ts
+var import_zod = require("zod");
+async function personalTokensRequest(baseUrl, hcOpts, path, init = {}) {
+  const fetchImpl = hcOpts?.fetch ?? fetch;
+  const rawHeaders = hcOpts?.headers;
+  const resolvedHeaders = typeof rawHeaders === "function" ? await rawHeaders() : rawHeaders ?? {};
+  return fetchImpl(`${baseUrl}${path}`, {
+    ...init,
+    // why: RequestInit['headers'] is HeadersInit (a union); we narrow to Record<string,string> after the static-record check above.
+    headers: { ...resolvedHeaders, ...init.headers }
+  });
+}
+async function callPersonalTokens(res) {
+  if (!res.ok) {
+    let message = fallbackMessage(res.status);
+    try {
+      const body = await res.json();
+      if (body.error) message = body.error;
+    } catch {
+    }
+    throw new TerrantulaError(res.status, { error: message });
+  }
+  return res.json();
+}
+function createOrgsClient(cloud, baseUrl, hcOpts) {
+  return {
+    create: withSchema(
+      import_zod.z.object({
+        name: import_zod.z.string().describe("Display name"),
+        slug: import_zod.z.string().describe("URL slug (lowercase, hyphens only)")
+      }),
+      (params) => call(cloud.orgs.$post({ json: params }))
+    ),
+    get: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].$get({ param: params }))
+    ),
+    listUsers: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].users.$get({ param: params }))
+    ),
+    inviteUser: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID"),
+        email: import_zod.z.string().describe("User email"),
+        name: import_zod.z.string().describe("User full name"),
+        role: import_zod.z.enum(["owner", "admin", "member"]).optional().describe("Role (owner|admin|member)")
+      }),
+      (params) => {
+        const { id, ...body } = params;
+        return call(cloud.orgs[":id"].users.$post({ param: { id }, json: body }));
+      }
+    ),
+    updateUserRole: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID"),
+        userId: import_zod.z.string().describe("User ID"),
+        role: import_zod.z.enum(["owner", "admin", "member"]).describe("New role")
+      }),
+      (params) => {
+        const { id, userId, ...body } = params;
+        return call(
+          cloud.orgs[":id"].users[":userId"].$patch({ param: { id, userId }, json: body })
+        );
+      }
+    ),
+    removeUser: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID"),
+        userId: import_zod.z.string().describe("User ID")
+      }),
+      (params) => call(cloud.orgs[":id"].users[":userId"].$delete({ param: params }))
+    ),
+    leave: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].leave.$post({ param: params }))
+    ),
+    delete: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].$delete({ param: params }))
+    ),
+    listPersonalTokens: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID")
+      }),
+      async (params) => callPersonalTokens(
+        await personalTokensRequest(baseUrl, hcOpts, `/orgs/${params.id}/personal-tokens`)
+      )
+    ),
+    createPersonalToken: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID"),
+        name: import_zod.z.string().describe("Token label"),
+        expiresAt: import_zod.z.string().datetime().optional().describe("Optional ISO expiry")
+      }),
+      async (params) => {
+        const { id, ...body } = params;
+        return callPersonalTokens(
+          await personalTokensRequest(baseUrl, hcOpts, `/orgs/${id}/personal-tokens`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          })
+        );
+      }
+    ),
+    revokePersonalToken: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID"),
+        tokenId: import_zod.z.string().describe("Personal token ID")
+      }),
+      async (params) => callPersonalTokens(
+        await personalTokensRequest(
+          baseUrl,
+          hcOpts,
+          `/orgs/${params.id}/personal-tokens/${params.tokenId}`,
+          { method: "DELETE" }
+        )
+      )
+    ),
+    listSsoExtras: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID")
+      }),
+      async (params) => callPersonalTokens(
+        await personalTokensRequest(baseUrl, hcOpts, `/orgs/${params.id}/sso-extras`)
+      )
+    ),
+    setSsoForce: withSchema(
+      import_zod.z.object({
+        id: import_zod.z.string().describe("Organization ID"),
+        providerId: import_zod.z.string().describe("SSO provider ID"),
+        forceSso: import_zod.z.boolean().describe("Force-SSO toggle for this provider")
+      }),
+      async (params) => callPersonalTokens(
+        await personalTokensRequest(
+          baseUrl,
+          hcOpts,
+          `/orgs/${params.id}/sso-extras/${params.providerId}`,
+          {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ forceSso: params.forceSso })
+          }
+        )
+      )
+    )
+  };
+}
+
+// src/projects.ts
+var import_zod2 = require("zod");
+var import_client = require("hono/client");
+function createProjectsClient(cloud, baseUrl, hcOpts) {
+  return {
+    list: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects.$get({ param: params }))
+    ),
+    create: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        name: import_zod2.z.string().describe("Project name"),
+        slug: import_zod2.z.string().describe("URL slug (lowercase, hyphens only)")
+      }),
+      (params) => {
+        const { orgId, ...body } = params;
+        return call(cloud.orgs[":orgId"].projects.$post({ param: { orgId }, json: body }));
+      }
+    ),
+    get: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects[":projectId"].$get({ param: params }))
+    ),
+    delete: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects[":projectId"].$delete({ param: params }))
+    ),
+    update: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID"),
+        name: import_zod2.z.string().optional().describe("New project name"),
+        metadata: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Per-project UI settings")
+      }),
+      (params) => {
+        const { orgId, projectId, ...body } = params;
+        return call(
+          cloud.orgs[":orgId"].projects[":projectId"].$put({
+            param: { orgId, projectId },
+            json: body
+          })
+        );
+      }
+    ),
+    listMembers: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects[":projectId"].members.$get({ param: params }))
+    ),
+    addMember: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID"),
+        userId: import_zod2.z.string().describe("User ID"),
+        role: import_zod2.z.enum(["owner", "admin", "member", "viewer"]).optional().describe("Role (owner|admin|member|viewer)"),
+        envName: import_zod2.z.string().optional().describe("Optional env scope; omit for project-wide access")
+      }),
+      (params) => {
+        const { orgId, projectId, ...body } = params;
+        return call(
+          cloud.orgs[":orgId"].projects[":projectId"].members.$post({
+            param: { orgId, projectId },
+            json: body
+          })
+        );
+      }
+    ),
+    removeMember: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID"),
+        userId: import_zod2.z.string().describe("User ID")
+      }),
+      (params) => call(
+        cloud.orgs[":orgId"].projects[":projectId"].members[":userId"].$delete({
+          param: params
+        })
+      )
+    ),
+    updateCellScopes: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID"),
+        userId: import_zod2.z.string().describe("User ID"),
+        cellScopes: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.null()]).describe("null = all cells; array = restrict to listed cell-label values")
+      }),
+      (params) => {
+        const { orgId, projectId, userId, cellScopes } = params;
+        return call(
+          cloud.orgs[":orgId"].projects[":projectId"].members[":userId"]["cell-scopes"].$put({
+            param: { orgId, projectId, userId },
+            json: { cellScopes }
+          })
+        );
+      }
+    ),
+    listTokens: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID")
+      }),
+      (params) => call(
+        (0, import_client.hc)(
+          `${baseUrl}/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
+          hcOpts
+        ).index.$get()
+      )
+    ),
+    createToken: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID"),
+        name: import_zod2.z.string().describe("Token name"),
+        role: import_zod2.z.enum(["owner", "admin", "member", "viewer"]).optional().describe("Role (owner|admin|member|viewer)"),
+        expiresAt: import_zod2.z.string().optional().describe("Expiry timestamp (ISO 8601)"),
+        envName: import_zod2.z.string().optional().describe("Optional env scope; omit for project-wide access"),
+        cellScopes: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.null()]).optional().describe(
+          "Optional cell scope; null/omitted = all cells, array = restrict to listed cell-label values"
+        )
+      }),
+      (params) => {
+        const { orgId, projectId, ...body } = params;
+        return call(
+          (0, import_client.hc)(
+            `${baseUrl}/orgs/${orgId}/projects/${projectId}/tokens`,
+            hcOpts
+          ).index.$post({ json: body })
+        );
+      }
+    ),
+    revokeToken: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization ID"),
+        projectId: import_zod2.z.string().describe("Project ID"),
+        tokenId: import_zod2.z.string().describe("Token ID")
+      }),
+      (params) => call(
+        (0, import_client.hc)(
+          `${baseUrl}/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
+          hcOpts
+        )[":tokenId"].$delete({ param: { tokenId: params.tokenId } })
+      )
+    )
+  };
+}
+
+// src/entities.ts
+var import_zod3 = require("zod");
+var import_types = require("@terrantula/types");
+function createEntityTypesClient(proj) {
+  return {
+    list: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["entity-types"].$get())
+    ),
+    get: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        name: import_zod3.z.string().describe("Entity type name")
+      }),
+      (params) => call(proj(params.projectId)["entity-types"][":name"].$get({ param: { name: params.name } }))
+    ),
+    create: withSchema(
+      import_types.EntityTypeSchema.extend({ projectId: import_zod3.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["entity-types"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      import_types.EntityTypeSchema.extend({ projectId: import_zod3.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(
+          proj(projectId)["entity-types"][":name"].$put({ param: { name: params.name }, json: body })
+        );
+      }
+    ),
+    delete: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        name: import_zod3.z.string().describe("Entity type name")
+      }),
+      (params) => call(
+        proj(params.projectId)["entity-types"][":name"].$delete({ param: { name: params.name } })
+      )
+    )
+  };
+}
+function createEntitiesClient(projEnv) {
+  return {
+    list: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        entityType: import_zod3.z.string().optional().describe("Filter by entity type"),
+        state: import_zod3.z.string().optional().describe("Filter by state"),
+        pool: import_zod3.z.string().optional().describe("Filter by pool membership"),
+        limit: import_zod3.z.coerce.number().int().min(1).max(100).optional().describe("Max results (1-100)"),
+        cursor: import_zod3.z.string().optional().describe("Pagination cursor")
+      }),
+      (params) => {
+        const { projectId, envName, ...query } = params;
+        return call(
+          projEnv(projectId, envName)["entities"].$get({ query: stringifyQuery(query) })
+        );
+      }
+    ),
+    get: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        id: import_zod3.z.string().uuid().describe("Entity ID")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName)["entities"][":id"].$get({ param: { id: params.id } }))
+    ),
+    create: withSchema(
+      import_types.EntitySchema.extend({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name")
+      }),
+      (params) => {
+        const { projectId, envName, ...body } = params;
+        return call(projEnv(projectId, envName)["entities"].$post({ json: body }));
+      }
+    ),
+    delete: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        id: import_zod3.z.string().uuid().describe("Entity ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["entities"][":id"].$delete({ param: { id: params.id } })
+      )
+    ),
+    setMetric: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        id: import_zod3.z.string().uuid().describe("Entity ID"),
+        metricName: import_zod3.z.string().describe("Metric name"),
+        value: import_zod3.z.number().describe("Metric value")
+      }),
+      (params) => {
+        const { projectId, envName, id, metricName, value } = params;
+        return call(
+          projEnv(projectId, envName)["entities"][":id"]["metrics"][":metricName"].$put({
+            param: { id, metricName },
+            json: { value }
+          })
+        );
+      }
+    ),
+    trigger: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        id: import_zod3.z.string().uuid().describe("Entity ID"),
+        actionName: import_zod3.z.string().describe("Action name"),
+        parameters: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Action parameters as JSON"),
+        recommendations: import_zod3.z.record(import_zod3.z.string()).optional().describe("Recommendation selections as JSON")
+      }).describe("Trigger an instance-scope action on a single entity"),
+      (params) => {
+        const { projectId, envName, id, actionName, parameters, recommendations } = params;
+        return call(
+          projEnv(projectId, envName)["entities"][":id"]["actions"][":actionName"].$post({
+            param: { id, actionName },
+            json: { parameters, recommendations }
+          })
+        );
+      }
+    ),
+    getMetrics: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        entityId: import_zod3.z.string().describe("Entity ID")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName).entities[":id"].metrics.$get({ param: { id: params.entityId } }))
+    ),
+    getMetricsBatch: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        entityIds: import_zod3.z.array(import_zod3.z.string().uuid()).min(1).max(500).describe("Entity IDs to fetch metrics for (max 500)")
+      }),
+      (params) => {
+        const { projectId, envName, entityIds } = params;
+        return call(
+          projEnv(projectId, envName).entities.metrics.$get({
+            query: { ids: entityIds.join(",") }
+          })
+        );
+      }
+    ),
+    getRelationships: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        entityId: import_zod3.z.string().describe("Entity ID")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName).entities[":id"].relationships.$get({ param: { id: params.entityId } }))
+    ),
+    syncStamp: withSchema(
+      import_zod3.z.object({
+        projectId: import_zod3.z.string().describe("Project ID"),
+        envName: import_zod3.z.string().describe("Environment name"),
+        id: import_zod3.z.string().uuid().describe("Entity ID"),
+        source: import_zod3.z.string().min(1).describe("Source-of-truth name (e.g. argo, k8s, aws)"),
+        observedAt: import_zod3.z.string().datetime().optional().describe("ISO-8601 observation timestamp; defaults to server time")
+      }),
+      (params) => {
+        const { projectId, envName, id, source, observedAt } = params;
+        return call(
+          projEnv(projectId, envName)["entities"][":id"]["sync-stamp"].$post({
+            param: { id },
+            json: { source, observedAt }
+          })
+        );
+      }
+    )
+  };
+}
+
+// src/cells.ts
+var import_zod4 = require("zod");
+var import_types2 = require("@terrantula/types");
+function createCellsClient(proj) {
+  return {
+    list: withSchema(
+      import_zod4.z.object({
+        projectId: import_zod4.z.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["cells"].$get())
+    ),
+    get: withSchema(
+      import_zod4.z.object({
+        projectId: import_zod4.z.string().describe("Project ID"),
+        name: import_zod4.z.string().describe("Cell name")
+      }),
+      (params) => call(proj(params.projectId)["cells"][":name"].$get({ param: { name: params.name } }))
+    ),
+    create: withSchema(
+      import_types2.CellSchema.extend({ projectId: import_zod4.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["cells"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      import_types2.CellSchema.extend({ projectId: import_zod4.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(
+          proj(projectId)["cells"][":name"].$put({ param: { name: params.name }, json: body })
+        );
+      }
+    ),
+    delete: withSchema(
+      import_zod4.z.object({
+        projectId: import_zod4.z.string().describe("Project ID"),
+        name: import_zod4.z.string().describe("Cell name")
+      }),
+      (params) => call(proj(params.projectId)["cells"][":name"].$delete({ param: { name: params.name } }))
+    ),
+    listMembers: withSchema(
+      import_zod4.z.object({
+        projectId: import_zod4.z.string().describe("Project ID"),
+        name: import_zod4.z.string().describe("Cell name")
+      }),
+      (params) => call(
+        proj(params.projectId)["cells"][":name"]["members"].$get({ param: { name: params.name } })
+      )
+    ),
+    addMember: withSchema(
+      import_zod4.z.object({
+        projectId: import_zod4.z.string().describe("Project ID"),
+        name: import_zod4.z.string().describe("Cell name"),
+        entityId: import_zod4.z.string().uuid().describe("Entity ID")
+      }),
+      (params) => {
+        const { projectId, name, entityId } = params;
+        return call(
+          proj(projectId)["cells"][":name"]["members"].$post({
+            param: { name },
+            json: { entityId }
+          })
+        );
+      }
+    ),
+    removeMember: withSchema(
+      import_zod4.z.object({
+        projectId: import_zod4.z.string().describe("Project ID"),
+        name: import_zod4.z.string().describe("Cell name"),
+        entityId: import_zod4.z.string().uuid().describe("Entity ID")
+      }),
+      (params) => call(
+        proj(params.projectId)["cells"][":name"]["members"][":entityId"].$delete({
+          param: { name: params.name, entityId: params.entityId }
+        })
+      )
+    )
+  };
+}
+
+// src/relationships.ts
+var import_zod5 = require("zod");
+var import_types3 = require("@terrantula/types");
+function createRelationshipTypesClient(proj) {
+  return {
+    list: withSchema(
+      import_zod5.z.object({
+        projectId: import_zod5.z.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["relationship-types"].$get())
+    ),
+    get: withSchema(
+      import_zod5.z.object({
+        projectId: import_zod5.z.string().describe("Project ID"),
+        name: import_zod5.z.string().describe("Relationship type name")
+      }),
+      (params) => call(
+        proj(params.projectId)["relationship-types"][":name"].$get({
+          param: { name: params.name }
+        })
+      )
+    ),
+    create: withSchema(
+      import_types3.RelationshipTypeSchema.extend({ projectId: import_zod5.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["relationship-types"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      import_types3.RelationshipTypeSchema.extend({ projectId: import_zod5.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(
+          proj(projectId)["relationship-types"][":name"].$put({
+            param: { name: params.name },
+            json: body
+          })
+        );
+      }
+    ),
+    delete: withSchema(
+      import_zod5.z.object({
+        projectId: import_zod5.z.string().describe("Project ID"),
+        name: import_zod5.z.string().describe("Relationship type name")
+      }),
+      (params) => call(
+        proj(params.projectId)["relationship-types"][":name"].$delete({
+          param: { name: params.name }
+        })
+      )
+    )
+  };
+}
+function createRelationshipsClient(projEnv) {
+  return {
+    list: withSchema(
+      import_zod5.z.object({
+        projectId: import_zod5.z.string().describe("Project ID"),
+        envName: import_zod5.z.string().describe("Environment name"),
+        relationshipType: import_zod5.z.string().optional().describe("Filter by relationship type"),
+        state: import_zod5.z.string().optional().describe("Filter by state"),
+        fromEntity: import_zod5.z.string().uuid().optional().describe("Filter by from-entity ID"),
+        toEntity: import_zod5.z.string().uuid().optional().describe("Filter by to-entity ID"),
+        fromEntityPool: import_zod5.z.string().optional().describe("Filter by from-entity pool"),
+        toEntityPool: import_zod5.z.string().optional().describe("Filter by to-entity pool"),
+        limit: import_zod5.z.coerce.number().int().min(1).max(100).optional().describe("Max results (1-100)")
+      }),
+      (params) => {
+        const { projectId, envName, ...query } = params;
+        return call(
+          projEnv(projectId, envName)["relationships"].$get({ query: stringifyQuery(query) })
+        );
+      }
+    ),
+    get: withSchema(
+      import_zod5.z.object({
+        projectId: import_zod5.z.string().describe("Project ID"),
+        envName: import_zod5.z.string().describe("Environment name"),
+        id: import_zod5.z.string().uuid().describe("Relationship ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["relationships"][":id"].$get({ param: { id: params.id } })
+      )
+    ),
+    create: withSchema(
+      import_types3.RelationshipSchema.extend({
+        projectId: import_zod5.z.string().describe("Project ID"),
+        envName: import_zod5.z.string().describe("Environment name")
+      }),
+      (params) => {
+        const { projectId, envName, ...body } = params;
+        return call(projEnv(projectId, envName)["relationships"].$post({ json: body }));
+      }
+    ),
+    delete: withSchema(
+      import_zod5.z.object({
+        projectId: import_zod5.z.string().describe("Project ID"),
+        envName: import_zod5.z.string().describe("Environment name"),
+        id: import_zod5.z.string().uuid().describe("Relationship ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["relationships"][":id"].$delete({ param: { id: params.id } })
+      )
+    )
+  };
+}
+
+// src/actions.ts
+var import_zod6 = require("zod");
+var import_types4 = require("@terrantula/types");
+function createActionsClient(proj, projEnv) {
+  return {
+    list: withSchema(
+      import_zod6.z.object({
+        projectId: import_zod6.z.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["actions"].$get())
+    ),
+    get: withSchema(
+      import_zod6.z.object({
+        projectId: import_zod6.z.string().describe("Project ID"),
+        name: import_zod6.z.string().describe("Action name")
+      }),
+      (params) => call(proj(params.projectId)["actions"][":name"].$get({ param: { name: params.name } }))
+    ),
+    create: withSchema(
+      import_types4.ActionSchema.extend({ projectId: import_zod6.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["actions"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      import_types4.ActionSchema.extend({ projectId: import_zod6.z.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(
+          proj(projectId)["actions"][":name"].$put({ param: { name: params.name }, json: body })
+        );
+      }
+    ),
+    delete: withSchema(
+      import_zod6.z.object({
+        projectId: import_zod6.z.string().describe("Project ID"),
+        name: import_zod6.z.string().describe("Action name")
+      }),
+      (params) => call(
+        proj(params.projectId)["actions"][":name"].$delete({ param: { name: params.name } })
+      )
+    ),
+    run: withSchema(
+      import_zod6.z.object({
+        projectId: import_zod6.z.string().describe("Project ID"),
+        envName: import_zod6.z.string().describe("Environment name"),
+        actionName: import_zod6.z.string().describe("Action name"),
+        parameters: import_zod6.z.record(import_zod6.z.unknown()).optional().describe("Action parameters as JSON"),
+        recommendations: import_zod6.z.record(import_zod6.z.string()).optional().describe("Recommendation selections as JSON")
+      }),
+      (params) => {
+        const { projectId, envName, actionName, parameters, recommendations } = params;
+        return call(
+          projEnv(projectId, envName)["actions"][":name"]["run"].$post({
+            param: { name: actionName },
+            json: { parameters, recommendations }
+          })
+        );
+      }
+    )
+  };
+}
+function createActionRunsClient(projEnv) {
+  return {
+    list: withSchema(
+      import_zod6.z.object({
+        projectId: import_zod6.z.string().describe("Project ID"),
+        envName: import_zod6.z.string().describe("Environment name"),
+        actionName: import_zod6.z.string().optional().describe("Filter by action name"),
+        entityId: import_zod6.z.string().uuid().optional().describe("Filter by entity ID"),
+        status: import_zod6.z.enum(["pending", "running", "succeeded", "failed", "cancelled"]).optional().describe("Filter by status"),
+        limit: import_zod6.z.coerce.number().int().min(1).max(100).optional().describe("Max results (1-100)")
+      }),
+      (params) => {
+        const { projectId, envName, ...query } = params;
+        return call(
+          projEnv(projectId, envName)["action-runs"].$get({ query: stringifyQuery(query) })
+        );
+      }
+    ),
+    get: withSchema(
+      import_zod6.z.object({
+        projectId: import_zod6.z.string().describe("Project ID"),
+        envName: import_zod6.z.string().describe("Environment name"),
+        id: import_zod6.z.string().uuid().describe("Action run ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["action-runs"][":id"].$get({ param: { id: params.id } })
+      )
+    ),
+    cancel: withSchema(
+      import_zod6.z.object({
+        projectId: import_zod6.z.string().describe("Project ID"),
+        envName: import_zod6.z.string().describe("Environment name"),
+        id: import_zod6.z.string().uuid().describe("Action run ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["action-runs"][":id"].$delete({ param: { id: params.id } })
+      )
+    )
+  };
+}
+
+// src/secrets.ts
+var import_zod7 = require("zod");
+var import_types5 = require("@terrantula/types");
+function createSecretsClient(projEnv) {
+  return {
+    list: withSchema(
+      import_zod7.z.object({
+        projectId: import_zod7.z.string().describe("Project ID"),
+        envName: import_zod7.z.string().describe("Environment name")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName)["secrets"].$get())
+    ),
+    get: withSchema(
+      import_zod7.z.object({
+        projectId: import_zod7.z.string().describe("Project ID"),
+        envName: import_zod7.z.string().describe("Environment name"),
+        name: import_zod7.z.string().describe("Secret name")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["secrets"][":name"].$get({ param: { name: params.name } })
+      )
+    ),
+    create: withSchema(
+      import_zod7.z.object({
+        projectId: import_zod7.z.string().describe("Project ID"),
+        envName: import_zod7.z.string().describe("Environment name"),
+        name: import_zod7.z.string().describe("Secret name"),
+        description: import_zod7.z.string().optional().describe("Description")
+      }),
+      (params) => {
+        const { projectId, envName, name, description } = params;
+        return call(
+          projEnv(projectId, envName)["secrets"].$post({ json: { kind: "Secret", name, description } })
+        );
+      }
+    ),
+    delete: withSchema(
+      import_zod7.z.object({
+        projectId: import_zod7.z.string().describe("Project ID"),
+        envName: import_zod7.z.string().describe("Environment name"),
+        name: import_zod7.z.string().describe("Secret name")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["secrets"][":name"].$delete({ param: { name: params.name } })
+      )
+    ),
+    setValue: withSchema(
+      import_zod7.z.object({
+        projectId: import_zod7.z.string().describe("Project ID"),
+        envName: import_zod7.z.string().describe("Environment name"),
+        name: import_zod7.z.string().describe("Secret name"),
+        value: import_zod7.z.string().min(1).describe("Secret value")
+      }),
+      (params) => {
+        const { projectId, envName, name, value } = params;
+        return call(
+          projEnv(projectId, envName)["secrets"][":name"]["value"].$put({
+            param: { name },
+            json: { value }
+          })
+        );
+      }
+    )
+  };
+}
+function createApplyClient(projEnv) {
+  return withSchema(
+    import_types5.ApplyRequestSchema.extend({
+      projectId: import_zod7.z.string().describe("Project ID"),
+      envName: import_zod7.z.string().describe("Environment name")
+    }),
+    (params) => {
+      const { projectId, envName, ...body } = params;
+      return call(projEnv(projectId, envName)["apply"].$post({ json: body }));
+    }
+  );
+}
+
+// src/github.ts
+var import_zod8 = require("zod");
+function createGithubClient(cloud, _baseUrl, _hcOpts) {
+  return {
+    connect: withSchema(
+      import_zod8.z.object({
+        projectId: import_zod8.z.string().describe("Project ID")
+      }),
+      (params) => call(cloud.api.github["install-url"].$post({ json: params }))
+    ),
+    installations: {
+      list: withSchema(
+        import_zod8.z.object({
+          orgId: import_zod8.z.string().describe("Organization ID")
+        }),
+        (params) => call(cloud.api.github.installations.$get({ query: params }))
+      ),
+      repos: withSchema(
+        import_zod8.z.object({
+          installationId: import_zod8.z.string().describe("Installation row ID")
+        }),
+        (params) => call(
+          cloud.api.github.installations[":installationId"].repos.$get({
+            param: params
+          })
+        )
+      ),
+      disconnect: withSchema(
+        import_zod8.z.object({
+          installationId: import_zod8.z.string().describe("Installation row ID")
+        }),
+        (params) => call(
+          cloud.api.github.installations[":installationId"].$delete({
+            param: params
+          })
+        )
+      ),
+      recover: withSchema(
+        import_zod8.z.object({
+          orgId: import_zod8.z.string().describe("Organization ID"),
+          installationId: import_zod8.z.number().int().positive().describe("GitHub installation ID (from the GitHub install URL)")
+        }),
+        (params) => call(cloud.api.github.installations.recover.$post({ json: params }))
+      )
+    },
+    projects: {
+      linkRepo: withSchema(
+        import_zod8.z.object({
+          orgId: import_zod8.z.string().describe("Organization ID"),
+          projectId: import_zod8.z.string().describe("Project ID"),
+          installationId: import_zod8.z.string().describe("Installation row ID"),
+          owner: import_zod8.z.string().describe("GitHub repo owner"),
+          name: import_zod8.z.string().describe("GitHub repo name")
+        }),
+        (params) => {
+          const { orgId, projectId, ...body } = params;
+          return call(
+            cloud.orgs[":orgId"].projects[":projectId"]["github-repos"].$post({
+              param: { orgId, projectId },
+              json: body
+            })
+          );
+        }
+      ),
+      unlinkRepo: withSchema(
+        import_zod8.z.object({
+          orgId: import_zod8.z.string().describe("Organization ID"),
+          projectId: import_zod8.z.string().describe("Project ID"),
+          owner: import_zod8.z.string().describe("GitHub repo owner"),
+          name: import_zod8.z.string().describe("GitHub repo name")
+        }),
+        (params) => call(
+          cloud.orgs[":orgId"].projects[":projectId"]["github-repos"][":owner"][":name"].$delete({
+            param: params
+          })
+        )
+      )
+    }
+  };
+}
+
+// src/export.ts
+var import_zod9 = require("zod");
+var SERVER_FIELDS = /* @__PURE__ */ new Set(["id", "projectId", "envId", "createdAt", "updatedAt"]);
+function stripServerFields(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (!SERVER_FIELDS.has(key)) out[key] = value;
+  }
+  return out;
+}
+function createExportCatalogFn(proj, projEnv) {
+  return withSchema(
+    import_zod9.z.object({
+      projectId: import_zod9.z.string().describe("Project ID"),
+      envName: import_zod9.z.string().describe("Environment name to export secret declarations from")
+    }).describe("Export every catalog kind as a single apply-shaped payload"),
+    async (params) => {
+      const projClient = proj(params.projectId);
+      const envClient = projEnv(params.projectId, params.envName);
+      const [entityTypes, cells, relationshipTypes, actions, secrets] = await Promise.all([
+        call(projClient["entity-types"].$get()),
+        call(projClient["cells"].$get()),
+        call(projClient["relationship-types"].$get()),
+        call(projClient["actions"].$get()),
+        call(envClient["secrets"].$get())
+      ]);
+      const items = [
+        ...entityTypes.map(
+          (r) => ({ kind: "EntityType", ...stripServerFields(r) })
+        ),
+        ...cells.map(
+          (r) => ({ kind: "Cell", ...stripServerFields(r) })
+        ),
+        ...relationshipTypes.map(
+          (r) => ({ kind: "RelationshipType", ...stripServerFields(r) })
+        ),
+        ...actions.map(
+          (r) => ({ kind: "Action", ...stripServerFields(r) })
+        ),
+        ...secrets.map(
+          (r) => ({ kind: "Secret", ...stripServerFields(r) })
+        )
+      ];
+      return { items };
+    }
+  );
+}
+
+// src/catalog-revisions.ts
+var import_zod10 = require("zod");
+function createCatalogRevisionsClient(proj) {
+  return {
+    list: withSchema(
+      import_zod10.z.object({
+        projectId: import_zod10.z.string().describe("Project ID"),
+        limit: import_zod10.z.coerce.number().int().min(1).max(200).optional().describe("Max revisions to return (1-200)")
+      }),
+      (params) => {
+        const { projectId, ...query } = params;
+        return call(
+          proj(projectId)["catalog-revisions"].$get({ query: stringifyQuery(query) })
+        );
+      }
+    ),
+    get: withSchema(
+      import_zod10.z.object({
+        projectId: import_zod10.z.string().describe("Project ID"),
+        id: import_zod10.z.string().uuid().describe("Revision ID")
+      }),
+      (params) => call(
+        proj(params.projectId)["catalog-revisions"][":id"].$get({ param: { id: params.id } })
+      )
+    ),
+    snapshots: withSchema(
+      import_zod10.z.object({
+        projectId: import_zod10.z.string().describe("Project ID"),
+        id: import_zod10.z.string().uuid().describe("Revision ID to read snapshots for")
+      }),
+      (params) => call(
+        proj(params.projectId)["catalog-revisions"][":id"]["snapshots"].$get({
+          param: { id: params.id }
+        })
+      )
+    ),
+    /**
+     * Roll back to a previous revision. Optionally filtered to a single hunk
+     * via `hunkId`. Destructive rollbacks (e.g. reverting a create) require
+     * `force: true`, mirroring POST /apply.
+     */
+    rollback: withSchema(
+      import_zod10.z.object({
+        projectId: import_zod10.z.string().describe("Project ID"),
+        id: import_zod10.z.string().uuid().describe("Revision ID to roll back to"),
+        hunkId: import_zod10.z.string().uuid().optional().describe("Single-hunk filter"),
+        force: import_zod10.z.boolean().optional().describe("Required if the inverse diff is destructive")
+      }),
+      (params) => {
+        const { projectId, id, hunkId, force } = params;
+        return call(
+          proj(projectId)["catalog-revisions"][":id"]["rollback"].$post({
+            param: { id },
+            json: { force: force ?? false },
+            query: hunkId ? stringifyQuery({ hunkId }) : void 0
+          })
+        );
+      }
+    )
+  };
+}
+
+// src/audit-events.ts
+var import_zod11 = require("zod");
+function createAuditEventsClient(proj) {
+  return {
+    list: withSchema(
+      import_zod11.z.object({
+        projectId: import_zod11.z.string().describe("Project ID"),
+        envName: import_zod11.z.string().optional().describe("Filter to a single env"),
+        actorType: import_zod11.z.enum(["user", "token"]).optional().describe("Filter by actor type"),
+        actorId: import_zod11.z.string().optional().describe("Filter by actor (user.id or apikey.id)"),
+        action: import_zod11.z.string().optional().describe('Comma-separated actions (e.g. "create,delete")'),
+        resourceKind: import_zod11.z.string().optional().describe("Filter to one resource kind (Entity | Token | Member | \u2026)"),
+        since: import_zod11.z.string().datetime().optional().describe("ISO timestamp; only events strictly after this are returned"),
+        limit: import_zod11.z.coerce.number().int().min(1).max(500).optional().describe("Max rows (1-500)")
+      }).describe("List audit events for a project \u2014 auditor-friendly read-only feed"),
+      (params) => {
+        const { projectId, ...query } = params;
+        return call(proj(projectId)["audit-events"].$get({ query: stringifyQuery(query) }));
+      }
+    )
+  };
+}
+
+// src/environments.ts
+var import_zod12 = require("zod");
+function createEnvironmentsClient(proj) {
+  return {
+    list: withSchema(
+      import_zod12.z.object({
+        projectId: import_zod12.z.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["environments"].$get())
+    ),
+    create: withSchema(
+      import_zod12.z.object({
+        projectId: import_zod12.z.string().describe("Project ID"),
+        name: import_zod12.z.string().min(1).max(31).regex(/^[a-z0-9][a-z0-9-]{0,30}$/).describe("Environment name (lowercase letters, digits, hyphens; max 31 chars)")
+      }),
+      (params) => {
+        const { projectId, name } = params;
+        return call(proj(projectId)["environments"].$post({ json: { name } }));
+      }
+    ),
+    delete: withSchema(
+      import_zod12.z.object({
+        projectId: import_zod12.z.string().describe("Project ID"),
+        name: import_zod12.z.string().describe("Environment name")
+      }),
+      (params) => call(
+        proj(params.projectId)["environments"][":envName"].$delete({
+          param: { envName: params.name }
+        })
+      )
+    )
+  };
+}
+
+// src/drift-events.ts
+var import_zod13 = require("zod");
+function createDriftEventsClient(projEnv) {
+  return {
+    list: withSchema(
+      import_zod13.z.object({
+        projectId: import_zod13.z.string().describe("Project ID"),
+        envName: import_zod13.z.string().describe("Environment name"),
+        status: import_zod13.z.enum(["open", "accepted", "reapplied", "snoozed"]).optional(),
+        kind: import_zod13.z.string().optional().describe("Filter by entity type name"),
+        entityId: import_zod13.z.string().uuid().optional(),
+        since: import_zod13.z.string().optional().describe("ISO timestamp lower bound on detectedAt"),
+        limit: import_zod13.z.coerce.number().int().min(1).max(500).optional()
+      }),
+      (params) => {
+        const { projectId, envName, ...query } = params;
+        return call(
+          projEnv(projectId, envName)["drift-events"].$get({ query: stringifyQuery(query) })
+        );
+      }
+    ),
+    count: withSchema(
+      import_zod13.z.object({ projectId: import_zod13.z.string(), envName: import_zod13.z.string() }),
+      (params) => call(projEnv(params.projectId, params.envName)["drift-events"].count.$get())
+    ),
+    get: withSchema(
+      import_zod13.z.object({
+        projectId: import_zod13.z.string(),
+        envName: import_zod13.z.string(),
+        id: import_zod13.z.string().uuid()
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["drift-events"][":id"].$get({
+          param: { id: params.id }
+        })
+      )
+    ),
+    accept: withSchema(
+      import_zod13.z.object({
+        projectId: import_zod13.z.string(),
+        envName: import_zod13.z.string(),
+        id: import_zod13.z.string().uuid()
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["drift-events"][":id"].accept.$post({
+          param: { id: params.id }
+        })
+      )
+    ),
+    reapply: withSchema(
+      import_zod13.z.object({
+        projectId: import_zod13.z.string(),
+        envName: import_zod13.z.string(),
+        id: import_zod13.z.string().uuid()
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["drift-events"][":id"].reapply.$post({
+          param: { id: params.id }
+        })
+      )
+    ),
+    snooze: withSchema(
+      import_zod13.z.object({
+        projectId: import_zod13.z.string(),
+        envName: import_zod13.z.string(),
+        id: import_zod13.z.string().uuid(),
+        untilSeconds: import_zod13.z.number().int().positive().optional()
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["drift-events"][":id"].snooze.$post({
+          param: { id: params.id },
+          json: { untilSeconds: params.untilSeconds }
+        })
+      )
+    )
+  };
+}
+
+// src/stats.ts
+var import_zod14 = require("zod");
+var WindowSchema = import_zod14.z.enum(["1h", "24h", "7d"]).optional().describe("Time window \u2014 default 24h");
+var BucketSchema = import_zod14.z.enum(["1m", "5m", "1h", "1d"]).optional().describe("Bucket granularity \u2014 default 1h");
+function createStatsClient(proj) {
+  return {
+    entitiesByState: withSchema(
+      import_zod14.z.object({
+        projectId: import_zod14.z.string().describe("Project ID"),
+        window: WindowSchema,
+        bucket: BucketSchema
+      }),
+      (params) => {
+        const { projectId, ...query } = params;
+        return call(proj(projectId)["stats"]["entities-by-state"].$get({ query: stringifyQuery(query) }));
+      }
+    ),
+    runsByType: withSchema(
+      import_zod14.z.object({
+        projectId: import_zod14.z.string().describe("Project ID"),
+        window: WindowSchema
+      }),
+      (params) => {
+        const { projectId, ...query } = params;
+        return call(proj(projectId)["stats"]["runs-by-type"].$get({ query: stringifyQuery(query) }));
+      }
+    ),
+    failingKinds: withSchema(
+      import_zod14.z.object({
+        projectId: import_zod14.z.string().describe("Project ID"),
+        window: WindowSchema
+      }),
+      (params) => {
+        const { projectId, ...query } = params;
+        return call(proj(projectId)["stats"]["failing-kinds"].$get({ query: stringifyQuery(query) }));
+      }
+    ),
+    driftDensity: withSchema(
+      import_zod14.z.object({
+        projectId: import_zod14.z.string().describe("Project ID"),
+        dim: import_zod14.z.string().optional().describe('Dimensions to bucket \u2014 e.g. "kind,cell"')
+      }),
+      (params) => {
+        const { projectId, ...query } = params;
+        return call(proj(projectId)["stats"]["drift-density"].$get({ query: stringifyQuery(query) }));
+      }
+    )
+  };
+}
+
+// src/notifications.ts
+var import_zod15 = require("zod");
+var import_client2 = require("hono/client");
+function createNotificationsClient(baseUrl, hcOpts) {
+  const c = (0, import_client2.hc)(`${baseUrl}/notifications`, hcOpts);
+  return {
+    list: withSchema(
+      import_zod15.z.object({
+        limit: import_zod15.z.coerce.number().int().min(1).max(100).optional(),
+        unread: import_zod15.z.boolean().optional()
+      }),
+      (params) => {
+        const query = {};
+        if (params.limit !== void 0) query.limit = String(params.limit);
+        if (params.unread !== void 0) query.unread = String(params.unread);
+        return call(c.index.$get({ query }));
+      }
+    ),
+    read: withSchema(
+      import_zod15.z.object({ id: import_zod15.z.string().uuid() }),
+      (params) => call(c[":id"].read.$post({ param: { id: params.id } }))
+    ),
+    readAll: withSchema(
+      import_zod15.z.object({}),
+      () => call(c["read-all"].$post())
+    )
+  };
+}
+
+// src/audit-export.ts
+var import_zod16 = require("zod");
+async function rawRequest(baseUrl, hcOpts, path, init = {}) {
+  const fetchImpl = hcOpts?.fetch ?? fetch;
+  const rawHeaders = hcOpts?.headers;
+  const resolvedHeaders = typeof rawHeaders === "function" ? await rawHeaders() : rawHeaders ?? {};
+  return fetchImpl(`${baseUrl}${path}`, {
+    ...init,
+    headers: {
+      ...resolvedHeaders,
+      ...init.headers
+    }
+  });
+}
+async function callRaw(res) {
+  if (!res.ok) {
+    let message = fallbackMessage(res.status);
+    try {
+      const body = await res.json();
+      if (body.error) message = body.error;
+    } catch {
+    }
+    throw new TerrantulaError(res.status, { error: message });
+  }
+  return res.json();
+}
+function createAuditExportClient(baseUrl, hcOpts) {
+  return {
+    /** GET /orgs/:orgId/audit-export/config — returns current config or throws 404. */
+    getConfig: withSchema(
+      import_zod16.z.object({ orgId: import_zod16.z.string().describe("Organization ID") }),
+      async (params) => callRaw(
+        await rawRequest(baseUrl, hcOpts, `/orgs/${params.orgId}/audit-export/config`)
+      )
+    ),
+    /** POST /orgs/:orgId/audit-export/config — upsert the S3 export config. */
+    setConfig: withSchema(
+      import_zod16.z.object({
+        orgId: import_zod16.z.string().describe("Organization ID"),
+        bucket: import_zod16.z.string().describe("S3 bucket name"),
+        region: import_zod16.z.string().describe("AWS region"),
+        roleArn: import_zod16.z.string().describe("IAM role ARN for assume-role"),
+        enabled: import_zod16.z.boolean().optional().describe("Enable/disable export")
+      }),
+      async (params) => {
+        const { orgId, ...body } = params;
+        return callRaw(
+          await rawRequest(baseUrl, hcOpts, `/orgs/${orgId}/audit-export/config`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          })
+        );
+      }
+    ),
+    /** POST /orgs/:orgId/audit-export/test-connection — dry-run write+delete. */
+    testConnection: withSchema(
+      import_zod16.z.object({
+        orgId: import_zod16.z.string().describe("Organization ID"),
+        bucket: import_zod16.z.string().describe("S3 bucket name"),
+        region: import_zod16.z.string().describe("AWS region"),
+        roleArn: import_zod16.z.string().describe("IAM role ARN for assume-role")
+      }),
+      async (params) => {
+        const { orgId, ...body } = params;
+        return callRaw(
+          await rawRequest(baseUrl, hcOpts, `/orgs/${orgId}/audit-export/test-connection`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          })
+        );
+      }
+    ),
+    /** GET /orgs/:orgId/audit-export/runs — recent batch run history. */
+    listRuns: withSchema(
+      import_zod16.z.object({
+        orgId: import_zod16.z.string().describe("Organization ID"),
+        limit: import_zod16.z.number().optional().describe("Max results (default 20, max 100)")
+      }),
+      async (params) => {
+        const qs = params.limit ? `?limit=${params.limit}` : "";
+        return callRaw(
+          await rawRequest(
+            baseUrl,
+            hcOpts,
+            `/orgs/${params.orgId}/audit-export/runs${qs}`
+          )
+        );
+      }
+    )
+  };
+}
+
+// src/user-preferences.ts
+var import_client3 = require("hono/client");
+function createUserPreferencesClient(baseUrl, hcOpts) {
+  const c = (0, import_client3.hc)(
+    `${baseUrl}/user/preferences`,
+    hcOpts
+  );
+  return {
+    get: (key) => call(c[":key"].$get({ param: { key } })),
+    set: (key, value) => call(
+      c[":key"].$put({
+        param: { key },
+        json: { value }
+      })
+    ),
+    delete: (key) => call(c[":key"].$delete({ param: { key } }))
+  };
+}
+
+// src/index.ts
+var createClient = (baseUrl, options = {}) => {
+  const opts = typeof options === "string" || typeof options === "function" ? { token: options } : options;
+  const headers = buildHeaders(opts.token);
+  const fetchImpl = opts.fetch;
+  const hcOpts = fetchImpl ? { headers, fetch: fetchImpl } : { headers };
+  const cloud = (0, import_client4.hc)(baseUrl, hcOpts);
+  const proj = (projectId) => (0, import_client4.hc)(`${baseUrl}/projects/${projectId}`, hcOpts);
+  const projEnv = (projectId, envName) => (0, import_client4.hc)(`${baseUrl}/projects/${projectId}/envs/${envName}`, hcOpts);
+  const cells = createCellsClient(proj);
+  const catalogRevisions = createCatalogRevisionsClient(proj);
+  const exportCatalog = createExportCatalogFn(proj, projEnv);
+  const client = {
+    orgs: createOrgsClient(cloud, baseUrl, hcOpts),
+    projects: createProjectsClient(cloud, baseUrl, hcOpts),
+    github: createGithubClient(cloud, baseUrl, hcOpts),
+    environments: createEnvironmentsClient(proj),
+    entityTypes: createEntityTypesClient(proj),
+    entities: createEntitiesClient(projEnv),
+    cells,
+    relationshipTypes: createRelationshipTypesClient(proj),
+    relationships: createRelationshipsClient(projEnv),
+    actions: createActionsClient(proj, projEnv),
+    actionRuns: createActionRunsClient(projEnv),
+    secrets: createSecretsClient(projEnv),
+    apply: createApplyClient(projEnv),
+    catalogRevisions,
+    auditEvents: createAuditEventsClient(proj),
+    driftEvents: createDriftEventsClient(projEnv),
+    stats: createStatsClient(proj),
+    notifications: createNotificationsClient(baseUrl, hcOpts),
+    auditExport: createAuditExportClient(baseUrl, hcOpts),
+    userPreferences: createUserPreferencesClient(baseUrl, hcOpts),
+    exportCatalog
+  };
+  let warnedPools = false;
+  let warnedApplyRevisions = false;
+  let warnedExportSchema = false;
+  Object.defineProperty(client, "pools", {
+    enumerable: false,
+    configurable: true,
+    get() {
+      if (!warnedPools) {
+        console.warn("[@terrantula/sdk] `client.pools` is deprecated \u2014 use `client.cells`. Will be removed next release.");
+        warnedPools = true;
+      }
+      return cells;
+    }
+  });
+  Object.defineProperty(client, "applyRevisions", {
+    enumerable: false,
+    configurable: true,
+    get() {
+      if (!warnedApplyRevisions) {
+        console.warn("[@terrantula/sdk] `client.applyRevisions` is deprecated \u2014 use `client.catalogRevisions`. Will be removed next release.");
+        warnedApplyRevisions = true;
+      }
+      return catalogRevisions;
+    }
+  });
+  Object.defineProperty(client, "exportSchema", {
+    enumerable: false,
+    configurable: true,
+    get() {
+      if (!warnedExportSchema) {
+        console.warn("[@terrantula/sdk] `client.exportSchema` is deprecated \u2014 use `client.exportCatalog`. Will be removed next release.");
+        warnedExportSchema = true;
+      }
+      return exportCatalog;
+    }
+  });
+  return client;
+};
+
+// src/local.ts
+var import_local = require("@terrantula/local");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_fs = require("fs");
+function defaultLocalDbPath() {
+  const dir = (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "terrantula");
+  (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  return (0, import_node_path.join)(dir, "local.db");
+}
+var createLocalClient = (options = {}) => {
+  const opened = (0, import_local.openLocalDb)({ path: options.dbPath ?? defaultLocalDbPath() });
+  const app = (0, import_local.createLocalApp)({ db: opened.db });
+  const localFetch = ((input, init) => {
+    const req = input instanceof Request ? input : new Request(input, init);
+    return Promise.resolve(app.fetch(req));
+  });
+  const client = createClient("http://local/api", { fetch: localFetch });
+  return Object.assign(client, { close: opened.close });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLocalClient
+});