@terrantula/sdk 0.0.1

package/dist/chunk-NTU2AEMP.mjs

@@ -0,0 +1,1507 @@
+// src/index.ts
+import { hc as hc4 } from "hono/client";
+import { Hono } from "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
+import { z } from "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(
+      z.object({
+        name: z.string().describe("Display name"),
+        slug: z.string().describe("URL slug (lowercase, hyphens only)")
+      }),
+      (params) => call(cloud.orgs.$post({ json: params }))
+    ),
+    get: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].$get({ param: params }))
+    ),
+    listUsers: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].users.$get({ param: params }))
+    ),
+    inviteUser: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID"),
+        email: z.string().describe("User email"),
+        name: z.string().describe("User full name"),
+        role: 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(
+      z.object({
+        id: z.string().describe("Organization ID"),
+        userId: z.string().describe("User ID"),
+        role: 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(
+      z.object({
+        id: z.string().describe("Organization ID"),
+        userId: z.string().describe("User ID")
+      }),
+      (params) => call(cloud.orgs[":id"].users[":userId"].$delete({ param: params }))
+    ),
+    leave: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].leave.$post({ param: params }))
+    ),
+    delete: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":id"].$delete({ param: params }))
+    ),
+    listPersonalTokens: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID")
+      }),
+      async (params) => callPersonalTokens(
+        await personalTokensRequest(baseUrl, hcOpts, `/orgs/${params.id}/personal-tokens`)
+      )
+    ),
+    createPersonalToken: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID"),
+        name: z.string().describe("Token label"),
+        expiresAt: 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(
+      z.object({
+        id: z.string().describe("Organization ID"),
+        tokenId: z.string().describe("Personal token ID")
+      }),
+      async (params) => callPersonalTokens(
+        await personalTokensRequest(
+          baseUrl,
+          hcOpts,
+          `/orgs/${params.id}/personal-tokens/${params.tokenId}`,
+          { method: "DELETE" }
+        )
+      )
+    ),
+    listSsoExtras: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID")
+      }),
+      async (params) => callPersonalTokens(
+        await personalTokensRequest(baseUrl, hcOpts, `/orgs/${params.id}/sso-extras`)
+      )
+    ),
+    setSsoForce: withSchema(
+      z.object({
+        id: z.string().describe("Organization ID"),
+        providerId: z.string().describe("SSO provider ID"),
+        forceSso: 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
+import { z as z2 } from "zod";
+import { hc } from "hono/client";
+function createProjectsClient(cloud, baseUrl, hcOpts) {
+  return {
+    list: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects.$get({ param: params }))
+    ),
+    create: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        name: z2.string().describe("Project name"),
+        slug: z2.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(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects[":projectId"].$get({ param: params }))
+    ),
+    delete: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects[":projectId"].$delete({ param: params }))
+    ),
+    update: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID"),
+        name: z2.string().optional().describe("New project name"),
+        metadata: z2.record(z2.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(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID")
+      }),
+      (params) => call(cloud.orgs[":orgId"].projects[":projectId"].members.$get({ param: params }))
+    ),
+    addMember: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID"),
+        userId: z2.string().describe("User ID"),
+        role: z2.enum(["owner", "admin", "member", "viewer"]).optional().describe("Role (owner|admin|member|viewer)"),
+        envName: z2.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(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID"),
+        userId: z2.string().describe("User ID")
+      }),
+      (params) => call(
+        cloud.orgs[":orgId"].projects[":projectId"].members[":userId"].$delete({
+          param: params
+        })
+      )
+    ),
+    updateCellScopes: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID"),
+        userId: z2.string().describe("User ID"),
+        cellScopes: z2.union([z2.array(z2.string()), z2.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(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID")
+      }),
+      (params) => call(
+        hc(
+          `${baseUrl}/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
+          hcOpts
+        ).index.$get()
+      )
+    ),
+    createToken: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID"),
+        name: z2.string().describe("Token name"),
+        role: z2.enum(["owner", "admin", "member", "viewer"]).optional().describe("Role (owner|admin|member|viewer)"),
+        expiresAt: z2.string().optional().describe("Expiry timestamp (ISO 8601)"),
+        envName: z2.string().optional().describe("Optional env scope; omit for project-wide access"),
+        cellScopes: z2.union([z2.array(z2.string()), z2.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(
+          hc(
+            `${baseUrl}/orgs/${orgId}/projects/${projectId}/tokens`,
+            hcOpts
+          ).index.$post({ json: body })
+        );
+      }
+    ),
+    revokeToken: withSchema(
+      z2.object({
+        orgId: z2.string().describe("Organization ID"),
+        projectId: z2.string().describe("Project ID"),
+        tokenId: z2.string().describe("Token ID")
+      }),
+      (params) => call(
+        hc(
+          `${baseUrl}/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
+          hcOpts
+        )[":tokenId"].$delete({ param: { tokenId: params.tokenId } })
+      )
+    )
+  };
+}
+
+// src/entities.ts
+import { z as z3 } from "zod";
+import {
+  EntityTypeSchema,
+  EntitySchema
+} from "@terrantula/types";
+function createEntityTypesClient(proj) {
+  return {
+    list: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["entity-types"].$get())
+    ),
+    get: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        name: z3.string().describe("Entity type name")
+      }),
+      (params) => call(proj(params.projectId)["entity-types"][":name"].$get({ param: { name: params.name } }))
+    ),
+    create: withSchema(
+      EntityTypeSchema.extend({ projectId: z3.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["entity-types"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      EntityTypeSchema.extend({ projectId: z3.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(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        name: z3.string().describe("Entity type name")
+      }),
+      (params) => call(
+        proj(params.projectId)["entity-types"][":name"].$delete({ param: { name: params.name } })
+      )
+    )
+  };
+}
+function createEntitiesClient(projEnv) {
+  return {
+    list: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        entityType: z3.string().optional().describe("Filter by entity type"),
+        state: z3.string().optional().describe("Filter by state"),
+        pool: z3.string().optional().describe("Filter by pool membership"),
+        limit: z3.coerce.number().int().min(1).max(100).optional().describe("Max results (1-100)"),
+        cursor: z3.string().optional().describe("Pagination cursor")
+      }),
+      (params) => {
+        const { projectId, envName, ...query } = params;
+        return call(
+          projEnv(projectId, envName)["entities"].$get({ query: stringifyQuery(query) })
+        );
+      }
+    ),
+    get: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        id: z3.string().uuid().describe("Entity ID")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName)["entities"][":id"].$get({ param: { id: params.id } }))
+    ),
+    create: withSchema(
+      EntitySchema.extend({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name")
+      }),
+      (params) => {
+        const { projectId, envName, ...body } = params;
+        return call(projEnv(projectId, envName)["entities"].$post({ json: body }));
+      }
+    ),
+    delete: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        id: z3.string().uuid().describe("Entity ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["entities"][":id"].$delete({ param: { id: params.id } })
+      )
+    ),
+    setMetric: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        id: z3.string().uuid().describe("Entity ID"),
+        metricName: z3.string().describe("Metric name"),
+        value: z3.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(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        id: z3.string().uuid().describe("Entity ID"),
+        actionName: z3.string().describe("Action name"),
+        parameters: z3.record(z3.unknown()).optional().describe("Action parameters as JSON"),
+        recommendations: z3.record(z3.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(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        entityId: z3.string().describe("Entity ID")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName).entities[":id"].metrics.$get({ param: { id: params.entityId } }))
+    ),
+    getMetricsBatch: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        entityIds: z3.array(z3.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(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        entityId: z3.string().describe("Entity ID")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName).entities[":id"].relationships.$get({ param: { id: params.entityId } }))
+    ),
+    syncStamp: withSchema(
+      z3.object({
+        projectId: z3.string().describe("Project ID"),
+        envName: z3.string().describe("Environment name"),
+        id: z3.string().uuid().describe("Entity ID"),
+        source: z3.string().min(1).describe("Source-of-truth name (e.g. argo, k8s, aws)"),
+        observedAt: z3.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
+import { z as z4 } from "zod";
+import { CellSchema } from "@terrantula/types";
+function createCellsClient(proj) {
+  return {
+    list: withSchema(
+      z4.object({
+        projectId: z4.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["cells"].$get())
+    ),
+    get: withSchema(
+      z4.object({
+        projectId: z4.string().describe("Project ID"),
+        name: z4.string().describe("Cell name")
+      }),
+      (params) => call(proj(params.projectId)["cells"][":name"].$get({ param: { name: params.name } }))
+    ),
+    create: withSchema(
+      CellSchema.extend({ projectId: z4.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["cells"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      CellSchema.extend({ projectId: z4.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(
+          proj(projectId)["cells"][":name"].$put({ param: { name: params.name }, json: body })
+        );
+      }
+    ),
+    delete: withSchema(
+      z4.object({
+        projectId: z4.string().describe("Project ID"),
+        name: z4.string().describe("Cell name")
+      }),
+      (params) => call(proj(params.projectId)["cells"][":name"].$delete({ param: { name: params.name } }))
+    ),
+    listMembers: withSchema(
+      z4.object({
+        projectId: z4.string().describe("Project ID"),
+        name: z4.string().describe("Cell name")
+      }),
+      (params) => call(
+        proj(params.projectId)["cells"][":name"]["members"].$get({ param: { name: params.name } })
+      )
+    ),
+    addMember: withSchema(
+      z4.object({
+        projectId: z4.string().describe("Project ID"),
+        name: z4.string().describe("Cell name"),
+        entityId: z4.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(
+      z4.object({
+        projectId: z4.string().describe("Project ID"),
+        name: z4.string().describe("Cell name"),
+        entityId: z4.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
+import { z as z5 } from "zod";
+import { RelationshipTypeSchema, RelationshipSchema } from "@terrantula/types";
+function createRelationshipTypesClient(proj) {
+  return {
+    list: withSchema(
+      z5.object({
+        projectId: z5.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["relationship-types"].$get())
+    ),
+    get: withSchema(
+      z5.object({
+        projectId: z5.string().describe("Project ID"),
+        name: z5.string().describe("Relationship type name")
+      }),
+      (params) => call(
+        proj(params.projectId)["relationship-types"][":name"].$get({
+          param: { name: params.name }
+        })
+      )
+    ),
+    create: withSchema(
+      RelationshipTypeSchema.extend({ projectId: z5.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["relationship-types"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      RelationshipTypeSchema.extend({ projectId: z5.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(
+      z5.object({
+        projectId: z5.string().describe("Project ID"),
+        name: z5.string().describe("Relationship type name")
+      }),
+      (params) => call(
+        proj(params.projectId)["relationship-types"][":name"].$delete({
+          param: { name: params.name }
+        })
+      )
+    )
+  };
+}
+function createRelationshipsClient(projEnv) {
+  return {
+    list: withSchema(
+      z5.object({
+        projectId: z5.string().describe("Project ID"),
+        envName: z5.string().describe("Environment name"),
+        relationshipType: z5.string().optional().describe("Filter by relationship type"),
+        state: z5.string().optional().describe("Filter by state"),
+        fromEntity: z5.string().uuid().optional().describe("Filter by from-entity ID"),
+        toEntity: z5.string().uuid().optional().describe("Filter by to-entity ID"),
+        fromEntityPool: z5.string().optional().describe("Filter by from-entity pool"),
+        toEntityPool: z5.string().optional().describe("Filter by to-entity pool"),
+        limit: z5.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(
+      z5.object({
+        projectId: z5.string().describe("Project ID"),
+        envName: z5.string().describe("Environment name"),
+        id: z5.string().uuid().describe("Relationship ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["relationships"][":id"].$get({ param: { id: params.id } })
+      )
+    ),
+    create: withSchema(
+      RelationshipSchema.extend({
+        projectId: z5.string().describe("Project ID"),
+        envName: z5.string().describe("Environment name")
+      }),
+      (params) => {
+        const { projectId, envName, ...body } = params;
+        return call(projEnv(projectId, envName)["relationships"].$post({ json: body }));
+      }
+    ),
+    delete: withSchema(
+      z5.object({
+        projectId: z5.string().describe("Project ID"),
+        envName: z5.string().describe("Environment name"),
+        id: z5.string().uuid().describe("Relationship ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["relationships"][":id"].$delete({ param: { id: params.id } })
+      )
+    )
+  };
+}
+
+// src/actions.ts
+import { z as z6 } from "zod";
+import { ActionSchema } from "@terrantula/types";
+function createActionsClient(proj, projEnv) {
+  return {
+    list: withSchema(
+      z6.object({
+        projectId: z6.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["actions"].$get())
+    ),
+    get: withSchema(
+      z6.object({
+        projectId: z6.string().describe("Project ID"),
+        name: z6.string().describe("Action name")
+      }),
+      (params) => call(proj(params.projectId)["actions"][":name"].$get({ param: { name: params.name } }))
+    ),
+    create: withSchema(
+      ActionSchema.extend({ projectId: z6.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["actions"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      ActionSchema.extend({ projectId: z6.string().describe("Project ID") }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(
+          proj(projectId)["actions"][":name"].$put({ param: { name: params.name }, json: body })
+        );
+      }
+    ),
+    delete: withSchema(
+      z6.object({
+        projectId: z6.string().describe("Project ID"),
+        name: z6.string().describe("Action name")
+      }),
+      (params) => call(
+        proj(params.projectId)["actions"][":name"].$delete({ param: { name: params.name } })
+      )
+    ),
+    run: withSchema(
+      z6.object({
+        projectId: z6.string().describe("Project ID"),
+        envName: z6.string().describe("Environment name"),
+        actionName: z6.string().describe("Action name"),
+        parameters: z6.record(z6.unknown()).optional().describe("Action parameters as JSON"),
+        recommendations: z6.record(z6.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(
+      z6.object({
+        projectId: z6.string().describe("Project ID"),
+        envName: z6.string().describe("Environment name"),
+        actionName: z6.string().optional().describe("Filter by action name"),
+        entityId: z6.string().uuid().optional().describe("Filter by entity ID"),
+        status: z6.enum(["pending", "running", "succeeded", "failed", "cancelled"]).optional().describe("Filter by status"),
+        limit: z6.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(
+      z6.object({
+        projectId: z6.string().describe("Project ID"),
+        envName: z6.string().describe("Environment name"),
+        id: z6.string().uuid().describe("Action run ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["action-runs"][":id"].$get({ param: { id: params.id } })
+      )
+    ),
+    cancel: withSchema(
+      z6.object({
+        projectId: z6.string().describe("Project ID"),
+        envName: z6.string().describe("Environment name"),
+        id: z6.string().uuid().describe("Action run ID")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["action-runs"][":id"].$delete({ param: { id: params.id } })
+      )
+    )
+  };
+}
+
+// src/secrets.ts
+import { z as z7 } from "zod";
+import { ApplyRequestSchema } from "@terrantula/types";
+function createSecretsClient(projEnv) {
+  return {
+    list: withSchema(
+      z7.object({
+        projectId: z7.string().describe("Project ID"),
+        envName: z7.string().describe("Environment name")
+      }),
+      (params) => call(projEnv(params.projectId, params.envName)["secrets"].$get())
+    ),
+    get: withSchema(
+      z7.object({
+        projectId: z7.string().describe("Project ID"),
+        envName: z7.string().describe("Environment name"),
+        name: z7.string().describe("Secret name")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["secrets"][":name"].$get({ param: { name: params.name } })
+      )
+    ),
+    create: withSchema(
+      z7.object({
+        projectId: z7.string().describe("Project ID"),
+        envName: z7.string().describe("Environment name"),
+        name: z7.string().describe("Secret name"),
+        description: z7.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(
+      z7.object({
+        projectId: z7.string().describe("Project ID"),
+        envName: z7.string().describe("Environment name"),
+        name: z7.string().describe("Secret name")
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["secrets"][":name"].$delete({ param: { name: params.name } })
+      )
+    ),
+    setValue: withSchema(
+      z7.object({
+        projectId: z7.string().describe("Project ID"),
+        envName: z7.string().describe("Environment name"),
+        name: z7.string().describe("Secret name"),
+        value: z7.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(
+    ApplyRequestSchema.extend({
+      projectId: z7.string().describe("Project ID"),
+      envName: z7.string().describe("Environment name")
+    }),
+    (params) => {
+      const { projectId, envName, ...body } = params;
+      return call(projEnv(projectId, envName)["apply"].$post({ json: body }));
+    }
+  );
+}
+
+// src/github.ts
+import { z as z8 } from "zod";
+function createGithubClient(cloud, _baseUrl, _hcOpts) {
+  return {
+    connect: withSchema(
+      z8.object({
+        projectId: z8.string().describe("Project ID")
+      }),
+      (params) => call(cloud.api.github["install-url"].$post({ json: params }))
+    ),
+    installations: {
+      list: withSchema(
+        z8.object({
+          orgId: z8.string().describe("Organization ID")
+        }),
+        (params) => call(cloud.api.github.installations.$get({ query: params }))
+      ),
+      repos: withSchema(
+        z8.object({
+          installationId: z8.string().describe("Installation row ID")
+        }),
+        (params) => call(
+          cloud.api.github.installations[":installationId"].repos.$get({
+            param: params
+          })
+        )
+      ),
+      disconnect: withSchema(
+        z8.object({
+          installationId: z8.string().describe("Installation row ID")
+        }),
+        (params) => call(
+          cloud.api.github.installations[":installationId"].$delete({
+            param: params
+          })
+        )
+      ),
+      recover: withSchema(
+        z8.object({
+          orgId: z8.string().describe("Organization ID"),
+          installationId: z8.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(
+        z8.object({
+          orgId: z8.string().describe("Organization ID"),
+          projectId: z8.string().describe("Project ID"),
+          installationId: z8.string().describe("Installation row ID"),
+          owner: z8.string().describe("GitHub repo owner"),
+          name: z8.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(
+        z8.object({
+          orgId: z8.string().describe("Organization ID"),
+          projectId: z8.string().describe("Project ID"),
+          owner: z8.string().describe("GitHub repo owner"),
+          name: z8.string().describe("GitHub repo name")
+        }),
+        (params) => call(
+          cloud.orgs[":orgId"].projects[":projectId"]["github-repos"][":owner"][":name"].$delete({
+            param: params
+          })
+        )
+      )
+    }
+  };
+}
+
+// src/export.ts
+import { z as z9 } from "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(
+    z9.object({
+      projectId: z9.string().describe("Project ID"),
+      envName: z9.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
+import { z as z10 } from "zod";
+function createCatalogRevisionsClient(proj) {
+  return {
+    list: withSchema(
+      z10.object({
+        projectId: z10.string().describe("Project ID"),
+        limit: z10.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(
+      z10.object({
+        projectId: z10.string().describe("Project ID"),
+        id: z10.string().uuid().describe("Revision ID")
+      }),
+      (params) => call(
+        proj(params.projectId)["catalog-revisions"][":id"].$get({ param: { id: params.id } })
+      )
+    ),
+    snapshots: withSchema(
+      z10.object({
+        projectId: z10.string().describe("Project ID"),
+        id: z10.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(
+      z10.object({
+        projectId: z10.string().describe("Project ID"),
+        id: z10.string().uuid().describe("Revision ID to roll back to"),
+        hunkId: z10.string().uuid().optional().describe("Single-hunk filter"),
+        force: z10.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
+import { z as z11 } from "zod";
+function createAuditEventsClient(proj) {
+  return {
+    list: withSchema(
+      z11.object({
+        projectId: z11.string().describe("Project ID"),
+        envName: z11.string().optional().describe("Filter to a single env"),
+        actorType: z11.enum(["user", "token"]).optional().describe("Filter by actor type"),
+        actorId: z11.string().optional().describe("Filter by actor (user.id or apikey.id)"),
+        action: z11.string().optional().describe('Comma-separated actions (e.g. "create,delete")'),
+        resourceKind: z11.string().optional().describe("Filter to one resource kind (Entity | Token | Member | \u2026)"),
+        since: z11.string().datetime().optional().describe("ISO timestamp; only events strictly after this are returned"),
+        limit: z11.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
+import { z as z12 } from "zod";
+function createEnvironmentsClient(proj) {
+  return {
+    list: withSchema(
+      z12.object({
+        projectId: z12.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.projectId)["environments"].$get())
+    ),
+    create: withSchema(
+      z12.object({
+        projectId: z12.string().describe("Project ID"),
+        name: z12.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(
+      z12.object({
+        projectId: z12.string().describe("Project ID"),
+        name: z12.string().describe("Environment name")
+      }),
+      (params) => call(
+        proj(params.projectId)["environments"][":envName"].$delete({
+          param: { envName: params.name }
+        })
+      )
+    )
+  };
+}
+
+// src/drift-events.ts
+import { z as z13 } from "zod";
+function createDriftEventsClient(projEnv) {
+  return {
+    list: withSchema(
+      z13.object({
+        projectId: z13.string().describe("Project ID"),
+        envName: z13.string().describe("Environment name"),
+        status: z13.enum(["open", "accepted", "reapplied", "snoozed"]).optional(),
+        kind: z13.string().optional().describe("Filter by entity type name"),
+        entityId: z13.string().uuid().optional(),
+        since: z13.string().optional().describe("ISO timestamp lower bound on detectedAt"),
+        limit: z13.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(
+      z13.object({ projectId: z13.string(), envName: z13.string() }),
+      (params) => call(projEnv(params.projectId, params.envName)["drift-events"].count.$get())
+    ),
+    get: withSchema(
+      z13.object({
+        projectId: z13.string(),
+        envName: z13.string(),
+        id: z13.string().uuid()
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["drift-events"][":id"].$get({
+          param: { id: params.id }
+        })
+      )
+    ),
+    accept: withSchema(
+      z13.object({
+        projectId: z13.string(),
+        envName: z13.string(),
+        id: z13.string().uuid()
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["drift-events"][":id"].accept.$post({
+          param: { id: params.id }
+        })
+      )
+    ),
+    reapply: withSchema(
+      z13.object({
+        projectId: z13.string(),
+        envName: z13.string(),
+        id: z13.string().uuid()
+      }),
+      (params) => call(
+        projEnv(params.projectId, params.envName)["drift-events"][":id"].reapply.$post({
+          param: { id: params.id }
+        })
+      )
+    ),
+    snooze: withSchema(
+      z13.object({
+        projectId: z13.string(),
+        envName: z13.string(),
+        id: z13.string().uuid(),
+        untilSeconds: z13.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
+import { z as z14 } from "zod";
+var WindowSchema = z14.enum(["1h", "24h", "7d"]).optional().describe("Time window \u2014 default 24h");
+var BucketSchema = z14.enum(["1m", "5m", "1h", "1d"]).optional().describe("Bucket granularity \u2014 default 1h");
+function createStatsClient(proj) {
+  return {
+    entitiesByState: withSchema(
+      z14.object({
+        projectId: z14.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(
+      z14.object({
+        projectId: z14.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(
+      z14.object({
+        projectId: z14.string().describe("Project ID"),
+        window: WindowSchema
+      }),
+      (params) => {
+        const { projectId, ...query } = params;
+        return call(proj(projectId)["stats"]["failing-kinds"].$get({ query: stringifyQuery(query) }));
+      }
+    ),
+    driftDensity: withSchema(
+      z14.object({
+        projectId: z14.string().describe("Project ID"),
+        dim: z14.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
+import { z as z15 } from "zod";
+import { hc as hc2 } from "hono/client";
+function createNotificationsClient(baseUrl, hcOpts) {
+  const c = hc2(`${baseUrl}/notifications`, hcOpts);
+  return {
+    list: withSchema(
+      z15.object({
+        limit: z15.coerce.number().int().min(1).max(100).optional(),
+        unread: z15.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(
+      z15.object({ id: z15.string().uuid() }),
+      (params) => call(c[":id"].read.$post({ param: { id: params.id } }))
+    ),
+    readAll: withSchema(
+      z15.object({}),
+      () => call(c["read-all"].$post())
+    )
+  };
+}
+
+// src/audit-export.ts
+import { z as z16 } from "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(
+      z16.object({ orgId: z16.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(
+      z16.object({
+        orgId: z16.string().describe("Organization ID"),
+        bucket: z16.string().describe("S3 bucket name"),
+        region: z16.string().describe("AWS region"),
+        roleArn: z16.string().describe("IAM role ARN for assume-role"),
+        enabled: z16.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(
+      z16.object({
+        orgId: z16.string().describe("Organization ID"),
+        bucket: z16.string().describe("S3 bucket name"),
+        region: z16.string().describe("AWS region"),
+        roleArn: z16.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(
+      z16.object({
+        orgId: z16.string().describe("Organization ID"),
+        limit: z16.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
+import { hc as hc3 } from "hono/client";
+function createUserPreferencesClient(baseUrl, hcOpts) {
+  const c = hc3(
+    `${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 = hc4(baseUrl, hcOpts);
+  const proj = (projectId) => hc4(`${baseUrl}/projects/${projectId}`, hcOpts);
+  const projEnv = (projectId, envName) => hc4(`${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;
+};
+
+export {
+  TerrantulaError,
+  withSchema,
+  createClient
+};