@terrantula/sdk 0.5.2 → 0.6.0

package/dist/index.js

@@ -158,7 +158,7 @@ function createOrgsClient(cloud, baseUrl, hcOpts) {
         id: import_zod.z.string().describe("Organization ID")
       }),
       async (params) => callPersonalTokens(
-        await personalTokensRequest(baseUrl, hcOpts, `/orgs/${params.id}/personal-tokens`)
+        await personalTokensRequest(baseUrl, hcOpts, `/api/orgs/${params.id}/personal-tokens`)
       )
     ),
     createPersonalToken: withSchema(
@@ -170,7 +170,7 @@ function createOrgsClient(cloud, baseUrl, hcOpts) {
       async (params) => {
         const { id, ...body } = params;
         return callPersonalTokens(
-          await personalTokensRequest(baseUrl, hcOpts, `/orgs/${id}/personal-tokens`, {
+          await personalTokensRequest(baseUrl, hcOpts, `/api/orgs/${id}/personal-tokens`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(body)
@@ -187,7 +187,7 @@ function createOrgsClient(cloud, baseUrl, hcOpts) {
         await personalTokensRequest(
           baseUrl,
           hcOpts,
-          `/orgs/${params.id}/personal-tokens/${params.tokenId}`,
+          `/api/orgs/${params.id}/personal-tokens/${params.tokenId}`,
           { method: "DELETE" }
         )
       )
@@ -197,7 +197,7 @@ function createOrgsClient(cloud, baseUrl, hcOpts) {
         id: import_zod.z.string().describe("Organization ID")
       }),
       async (params) => callPersonalTokens(
-        await personalTokensRequest(baseUrl, hcOpts, `/orgs/${params.id}/sso-extras`)
+        await personalTokensRequest(baseUrl, hcOpts, `/api/orgs/${params.id}/sso-extras`)
       )
     ),
     setSsoForce: withSchema(
@@ -210,7 +210,7 @@ function createOrgsClient(cloud, baseUrl, hcOpts) {
         await personalTokensRequest(
           baseUrl,
           hcOpts,
-          `/orgs/${params.id}/sso-extras/${params.providerId}`,
+          `/api/orgs/${params.id}/sso-extras/${params.providerId}`,
           {
             method: "PATCH",
             headers: { "Content-Type": "application/json" },
@@ -336,7 +336,7 @@ function createProjectsClient(cloud, baseUrl, hcOpts) {
       }),
       (params) => call(
         (0, import_client.hc)(
-          `${baseUrl}/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
+          `${baseUrl}/api/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
           hcOpts
         ).index.$get()
       )
@@ -357,7 +357,7 @@ function createProjectsClient(cloud, baseUrl, hcOpts) {
         const { orgId, projectId, ...body } = params;
         return call(
           (0, import_client.hc)(
-            `${baseUrl}/orgs/${orgId}/projects/${projectId}/tokens`,
+            `${baseUrl}/api/orgs/${orgId}/projects/${projectId}/tokens`,
             hcOpts
           ).index.$post({ json: body })
         );
@@ -371,10 +371,42 @@ function createProjectsClient(cloud, baseUrl, hcOpts) {
       }),
       (params) => call(
         (0, import_client.hc)(
-          `${baseUrl}/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
+          `${baseUrl}/api/orgs/${params.orgId}/projects/${params.projectId}/tokens`,
           hcOpts
         )[":tokenId"].$delete({ param: { tokenId: params.tokenId } })
       )
+    ),
+    /**
+     * DELETE /projects/:projectId/nuke
+     * Wipe all project-scoped runtime + catalog rows. Callable with a project
+     * API token (terr_*) at admin or owner role. Preserves the project row,
+     * members, GitHub repo links, API tokens, and environments. Idempotent.
+     */
+    nuke: withSchema(
+      import_zod2.z.object({
+        orgId: import_zod2.z.string().describe("Organization slug"),
+        projectId: import_zod2.z.string().describe("Project ID to nuke")
+      }),
+      async (params) => {
+        const url = `${baseUrl}/api/${encodeURIComponent(params.orgId)}/${encodeURIComponent(params.projectId)}/nuke`;
+        const fetchImpl = hcOpts?.fetch ?? fetch;
+        const rawHeaders = hcOpts?.headers;
+        const resolvedHeaders = typeof rawHeaders === "function" ? await rawHeaders() : rawHeaders ?? {};
+        const res = await fetchImpl(url, {
+          method: "DELETE",
+          headers: resolvedHeaders
+        });
+        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();
+      }
     )
   };
 }
@@ -386,40 +418,49 @@ function createEntityTypesClient(proj) {
   return {
     list: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         projectId: import_zod3.z.string().describe("Project ID")
       }),
-      (params) => call(proj(params.projectId)["entity-types"].$get())
+      (params) => call(proj(params.orgId, params.projectId)["entity-types"].$get())
     ),
     get: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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 } }))
+      (params) => call(proj(params.orgId, params.projectId)["entity-types"][":name"].$get({ param: { name: params.name } }))
     ),
     create: withSchema(
-      import_types.EntityTypeSchema.extend({ projectId: import_zod3.z.string().describe("Project ID") }),
+      import_types.EntityTypeSchema.extend({
+        orgId: import_zod3.z.string().describe("Organization slug"),
+        projectId: import_zod3.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
-        return call(proj(projectId)["entity-types"].$post({ json: body }));
+        const { orgId, projectId, ...body } = params;
+        return call(proj(orgId, projectId)["entity-types"].$post({ json: body }));
       }
     ),
     update: withSchema(
-      import_types.EntityTypeSchema.extend({ projectId: import_zod3.z.string().describe("Project ID") }),
+      import_types.EntityTypeSchema.extend({
+        orgId: import_zod3.z.string().describe("Organization slug"),
+        projectId: import_zod3.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
+        const { orgId, projectId, ...body } = params;
         return call(
-          proj(projectId)["entity-types"][":name"].$put({ param: { name: params.name }, json: body })
+          proj(orgId, projectId)["entity-types"][":name"].$put({ param: { name: params.name }, json: body })
         );
       }
     ),
     delete: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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 } })
+        proj(params.orgId, params.projectId)["entity-types"][":name"].$delete({ param: { name: params.name } })
       )
     )
   };
@@ -428,6 +469,7 @@ function createEntitiesClient(projEnv) {
   return {
     list: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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"),
@@ -437,42 +479,46 @@ function createEntitiesClient(projEnv) {
         cursor: import_zod3.z.string().optional().describe("Pagination cursor")
       }),
       (params) => {
-        const { projectId, envName, ...query } = params;
+        const { orgId, projectId, envName, ...query } = params;
         return call(
-          projEnv(projectId, envName)["entities"].$get({ query: stringifyQuery(query) })
+          projEnv(orgId, projectId, envName)["entities"].$get({ query: stringifyQuery(query) })
         );
       }
     ),
     get: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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 } }))
+      (params) => call(projEnv(params.orgId, params.projectId, params.envName)["entities"][":id"].$get({ param: { id: params.id } }))
     ),
     create: withSchema(
       import_types.EntitySchema.extend({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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 }));
+        const { orgId, projectId, envName, ...body } = params;
+        return call(projEnv(orgId, projectId, envName)["entities"].$post({ json: body }));
       }
     ),
     delete: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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 } })
+        projEnv(params.orgId, params.projectId, params.envName)["entities"][":id"].$delete({ param: { id: params.id } })
       )
     ),
     setMetric: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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"),
@@ -480,9 +526,9 @@ function createEntitiesClient(projEnv) {
         value: import_zod3.z.number().describe("Metric value")
       }),
       (params) => {
-        const { projectId, envName, id, metricName, value } = params;
+        const { orgId, projectId, envName, id, metricName, value } = params;
         return call(
-          projEnv(projectId, envName)["entities"][":id"]["metrics"][":metricName"].$put({
+          projEnv(orgId, projectId, envName)["entities"][":id"]["metrics"][":metricName"].$put({
             param: { id, metricName },
             json: { value }
           })
@@ -491,6 +537,7 @@ function createEntitiesClient(projEnv) {
     ),
     trigger: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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"),
@@ -499,9 +546,9 @@ function createEntitiesClient(projEnv) {
         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;
+        const { orgId, projectId, envName, id, actionName, parameters, recommendations } = params;
         return call(
-          projEnv(projectId, envName)["entities"][":id"]["actions"][":actionName"].$post({
+          projEnv(orgId, projectId, envName)["entities"][":id"]["actions"][":actionName"].$post({
             param: { id, actionName },
             json: { parameters, recommendations }
           })
@@ -510,22 +557,24 @@ function createEntitiesClient(projEnv) {
     ),
     getMetrics: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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 } }))
+      (params) => call(projEnv(params.orgId, params.projectId, params.envName).entities[":id"].metrics.$get({ param: { id: params.entityId } }))
     ),
     getMetricsBatch: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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;
+        const { orgId, projectId, envName, entityIds } = params;
         return call(
-          projEnv(projectId, envName).entities.metrics.$get({
+          projEnv(orgId, projectId, envName).entities.metrics.$get({
             query: { ids: entityIds.join(",") }
           })
         );
@@ -533,14 +582,16 @@ function createEntitiesClient(projEnv) {
     ),
     getRelationships: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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 } }))
+      (params) => call(projEnv(params.orgId, params.projectId, params.envName).entities[":id"].relationships.$get({ param: { id: params.entityId } }))
     ),
     syncStamp: withSchema(
       import_zod3.z.object({
+        orgId: import_zod3.z.string().describe("Organization slug"),
         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"),
@@ -548,9 +599,9 @@ function createEntitiesClient(projEnv) {
         observedAt: import_zod3.z.string().datetime().optional().describe("ISO-8601 observation timestamp; defaults to server time")
       }),
       (params) => {
-        const { projectId, envName, id, source, observedAt } = params;
+        const { orgId, projectId, envName, id, source, observedAt } = params;
         return call(
-          projEnv(projectId, envName)["entities"][":id"]["sync-stamp"].$post({
+          projEnv(orgId, projectId, envName)["entities"][":id"]["sync-stamp"].$post({
             param: { id },
             json: { source, observedAt }
           })
@@ -567,76 +618,103 @@ function createCellsClient(proj) {
   return {
     list: withSchema(
       import_zod4.z.object({
+        orgId: import_zod4.z.string().describe("Organization slug"),
         projectId: import_zod4.z.string().describe("Project ID")
       }),
-      (params) => call(proj(params.projectId)["cells"].$get())
+      (params) => call(proj(params.orgId, params.projectId)["cells"].$get())
     ),
     get: withSchema(
       import_zod4.z.object({
+        orgId: import_zod4.z.string().describe("Organization slug"),
         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 } }))
+      (params) => call(proj(params.orgId, params.projectId)["cells"][":name"].$get({ param: { name: params.name } }))
     ),
     create: withSchema(
-      import_types2.CellSchema.extend({ projectId: import_zod4.z.string().describe("Project ID") }),
+      import_types2.CellSchema.extend({
+        orgId: import_zod4.z.string().describe("Organization slug"),
+        projectId: import_zod4.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
-        return call(proj(projectId)["cells"].$post({ json: body }));
+        const { orgId, projectId, ...body } = params;
+        return call(proj(orgId, projectId)["cells"].$post({ json: body }));
       }
     ),
     update: withSchema(
-      import_types2.CellSchema.extend({ projectId: import_zod4.z.string().describe("Project ID") }),
+      import_types2.CellSchema.extend({
+        orgId: import_zod4.z.string().describe("Organization slug"),
+        projectId: import_zod4.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
+        const { orgId, projectId, ...body } = params;
         return call(
-          proj(projectId)["cells"][":name"].$put({ param: { name: params.name }, json: body })
+          proj(orgId, projectId)["cells"][":name"].$put({ param: { name: params.name }, json: body })
         );
       }
     ),
     delete: withSchema(
       import_zod4.z.object({
+        orgId: import_zod4.z.string().describe("Organization slug"),
         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 } }))
+      (params) => call(proj(params.orgId, params.projectId)["cells"][":name"].$delete({ param: { name: params.name } }))
     ),
     listMembers: withSchema(
       import_zod4.z.object({
+        orgId: import_zod4.z.string().describe("Organization slug"),
         projectId: import_zod4.z.string().describe("Project ID"),
-        name: import_zod4.z.string().describe("Cell name")
+        name: import_zod4.z.string().describe("Cell name"),
+        envName: import_zod4.z.string().describe("Environment name").default("default")
       }),
-      (params) => call(
-        proj(params.projectId)["cells"][":name"]["members"].$get({ param: { name: params.name } })
-      )
+      (params) => {
+        const envName = params.envName ?? "default";
+        return call(
+          proj(params.orgId, params.projectId)["cells"][":name"]["members"].$get({
+            param: { name: params.name },
+            query: { envName }
+          })
+        );
+      }
     ),
     addMember: withSchema(
       import_zod4.z.object({
+        orgId: import_zod4.z.string().describe("Organization slug"),
         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")
+        entityName: import_zod4.z.string().describe("Entity name (M5-rework natural key)"),
+        entityTypeName: import_zod4.z.string().describe("Entity type name (M5-rework natural key)"),
+        envName: import_zod4.z.string().describe("Environment name").default("default")
       }),
       (params) => {
-        const { projectId, name, entityId } = params;
+        const { orgId, projectId, name, entityName, entityTypeName } = params;
+        const envName = params.envName ?? "default";
         return call(
-          proj(projectId)["cells"][":name"]["members"].$post({
+          proj(orgId, projectId)["cells"][":name"]["members"].$post({
             param: { name },
-            json: { entityId }
+            json: { entityName, entityTypeName, envName }
           })
         );
       }
     ),
     removeMember: withSchema(
       import_zod4.z.object({
+        orgId: import_zod4.z.string().describe("Organization slug"),
         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")
+        entityName: import_zod4.z.string().describe("Entity name (M5-rework natural key)"),
+        envName: import_zod4.z.string().describe("Environment name").default("default")
       }),
-      (params) => call(
-        proj(params.projectId)["cells"][":name"]["members"][":entityId"].$delete({
-          param: { name: params.name, entityId: params.entityId }
-        })
-      )
+      (params) => {
+        const envName = params.envName ?? "default";
+        return call(
+          proj(params.orgId, params.projectId)["cells"][":name"]["members"][":entityName"].$delete({
+            param: { name: params.name, entityName: params.entityName },
+            query: { envName }
+          })
+        );
+      }
     )
   };
 }
@@ -648,34 +726,42 @@ function createRelationshipTypesClient(proj) {
   return {
     list: withSchema(
       import_zod5.z.object({
+        orgId: import_zod5.z.string().describe("Organization slug"),
         projectId: import_zod5.z.string().describe("Project ID")
       }),
-      (params) => call(proj(params.projectId)["relationship-types"].$get())
+      (params) => call(proj(params.orgId, params.projectId)["relationship-types"].$get())
     ),
     get: withSchema(
       import_zod5.z.object({
+        orgId: import_zod5.z.string().describe("Organization slug"),
         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({
+        proj(params.orgId, params.projectId)["relationship-types"][":name"].$get({
           param: { name: params.name }
         })
       )
     ),
     create: withSchema(
-      import_types3.RelationshipTypeSchema.extend({ projectId: import_zod5.z.string().describe("Project ID") }),
+      import_types3.RelationshipTypeSchema.extend({
+        orgId: import_zod5.z.string().describe("Organization slug"),
+        projectId: import_zod5.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
-        return call(proj(projectId)["relationship-types"].$post({ json: body }));
+        const { orgId, projectId, ...body } = params;
+        return call(proj(orgId, projectId)["relationship-types"].$post({ json: body }));
       }
     ),
     update: withSchema(
-      import_types3.RelationshipTypeSchema.extend({ projectId: import_zod5.z.string().describe("Project ID") }),
+      import_types3.RelationshipTypeSchema.extend({
+        orgId: import_zod5.z.string().describe("Organization slug"),
+        projectId: import_zod5.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
+        const { orgId, projectId, ...body } = params;
         return call(
-          proj(projectId)["relationship-types"][":name"].$put({
+          proj(orgId, projectId)["relationship-types"][":name"].$put({
             param: { name: params.name },
             json: body
           })
@@ -684,11 +770,12 @@ function createRelationshipTypesClient(proj) {
     ),
     delete: withSchema(
       import_zod5.z.object({
+        orgId: import_zod5.z.string().describe("Organization slug"),
         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({
+        proj(params.orgId, params.projectId)["relationship-types"][":name"].$delete({
           param: { name: params.name }
         })
       )
@@ -699,6 +786,7 @@ function createRelationshipsClient(projEnv) {
   return {
     list: withSchema(
       import_zod5.z.object({
+        orgId: import_zod5.z.string().describe("Organization slug"),
         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"),
@@ -710,40 +798,43 @@ function createRelationshipsClient(projEnv) {
         limit: import_zod5.z.coerce.number().int().min(1).max(100).optional().describe("Max results (1-100)")
       }),
       (params) => {
-        const { projectId, envName, ...query } = params;
+        const { orgId, projectId, envName, ...query } = params;
         return call(
-          projEnv(projectId, envName)["relationships"].$get({ query: stringifyQuery(query) })
+          projEnv(orgId, projectId, envName)["relationships"].$get({ query: stringifyQuery(query) })
         );
       }
     ),
     get: withSchema(
       import_zod5.z.object({
+        orgId: import_zod5.z.string().describe("Organization slug"),
         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 } })
+        projEnv(params.orgId, params.projectId, params.envName)["relationships"][":id"].$get({ param: { id: params.id } })
       )
     ),
     create: withSchema(
       import_types3.RelationshipSchema.extend({
+        orgId: import_zod5.z.string().describe("Organization slug"),
         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 }));
+        const { orgId, projectId, envName, ...body } = params;
+        return call(projEnv(orgId, projectId, envName)["relationships"].$post({ json: body }));
       }
     ),
     delete: withSchema(
       import_zod5.z.object({
+        orgId: import_zod5.z.string().describe("Organization slug"),
         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 } })
+        projEnv(params.orgId, params.projectId, params.envName)["relationships"][":id"].$delete({ param: { id: params.id } })
       )
     )
   };
@@ -756,44 +847,54 @@ function createActionsClient(proj, projEnv) {
   return {
     list: withSchema(
       import_zod6.z.object({
+        orgId: import_zod6.z.string().describe("Organization slug"),
         projectId: import_zod6.z.string().describe("Project ID")
       }),
-      (params) => call(proj(params.projectId)["actions"].$get())
+      (params) => call(proj(params.orgId, params.projectId)["actions"].$get())
     ),
     get: withSchema(
       import_zod6.z.object({
+        orgId: import_zod6.z.string().describe("Organization slug"),
         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 } }))
+      (params) => call(proj(params.orgId, params.projectId)["actions"][":name"].$get({ param: { name: params.name } }))
     ),
     create: withSchema(
-      import_types4.ActionSchema.extend({ projectId: import_zod6.z.string().describe("Project ID") }),
+      import_types4.ActionSchema.extend({
+        orgId: import_zod6.z.string().describe("Organization slug"),
+        projectId: import_zod6.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
-        return call(proj(projectId)["actions"].$post({ json: body }));
+        const { orgId, projectId, ...body } = params;
+        return call(proj(orgId, projectId)["actions"].$post({ json: body }));
       }
     ),
     update: withSchema(
-      import_types4.ActionSchema.extend({ projectId: import_zod6.z.string().describe("Project ID") }),
+      import_types4.ActionSchema.extend({
+        orgId: import_zod6.z.string().describe("Organization slug"),
+        projectId: import_zod6.z.string().describe("Project ID")
+      }),
       (params) => {
-        const { projectId, ...body } = params;
+        const { orgId, projectId, ...body } = params;
         return call(
-          proj(projectId)["actions"][":name"].$put({ param: { name: params.name }, json: body })
+          proj(orgId, projectId)["actions"][":name"].$put({ param: { name: params.name }, json: body })
         );
       }
     ),
     delete: withSchema(
       import_zod6.z.object({
+        orgId: import_zod6.z.string().describe("Organization slug"),
         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 } })
+        proj(params.orgId, params.projectId)["actions"][":name"].$delete({ param: { name: params.name } })
       )
     ),
     run: withSchema(
       import_zod6.z.object({
+        orgId: import_zod6.z.string().describe("Organization slug"),
         projectId: import_zod6.z.string().describe("Project ID"),
         envName: import_zod6.z.string().describe("Environment name"),
         actionName: import_zod6.z.string().describe("Action name"),
@@ -801,9 +902,9 @@ function createActionsClient(proj, projEnv) {
         recommendations: import_zod6.z.record(import_zod6.z.string()).optional().describe("Recommendation selections as JSON")
       }),
       (params) => {
-        const { projectId, envName, actionName, parameters, recommendations } = params;
+        const { orgId, projectId, envName, actionName, parameters, recommendations } = params;
         return call(
-          projEnv(projectId, envName)["actions"][":name"]["run"].$post({
+          projEnv(orgId, projectId, envName)["actions"][":name"]["run"].$post({
             param: { name: actionName },
             json: { parameters, recommendations }
           })
@@ -816,6 +917,7 @@ function createActionRunsClient(projEnv) {
   return {
     list: withSchema(
       import_zod6.z.object({
+        orgId: import_zod6.z.string().describe("Organization slug"),
         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"),
@@ -824,30 +926,32 @@ function createActionRunsClient(projEnv) {
         limit: import_zod6.z.coerce.number().int().min(1).max(100).optional().describe("Max results (1-100)")
       }),
       (params) => {
-        const { projectId, envName, ...query } = params;
+        const { orgId, projectId, envName, ...query } = params;
         return call(
-          projEnv(projectId, envName)["action-runs"].$get({ query: stringifyQuery(query) })
+          projEnv(orgId, projectId, envName)["action-runs"].$get({ query: stringifyQuery(query) })
         );
       }
     ),
     get: withSchema(
       import_zod6.z.object({
+        orgId: import_zod6.z.string().describe("Organization slug"),
         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 } })
+        projEnv(params.orgId, params.projectId, params.envName)["action-runs"][":id"].$get({ param: { id: params.id } })
       )
     ),
     cancel: withSchema(
       import_zod6.z.object({
+        orgId: import_zod6.z.string().describe("Organization slug"),
         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 } })
+        projEnv(params.orgId, params.projectId, params.envName)["action-runs"][":id"].$delete({ param: { id: params.id } })
       )
     )
   };
@@ -860,56 +964,61 @@ function createSecretsClient(projEnv) {
   return {
     list: withSchema(
       import_zod7.z.object({
+        orgId: import_zod7.z.string().describe("Organization slug"),
         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())
+      (params) => call(projEnv(params.orgId, params.projectId, params.envName)["secrets"].$get())
     ),
     get: withSchema(
       import_zod7.z.object({
+        orgId: import_zod7.z.string().describe("Organization slug"),
         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 } })
+        projEnv(params.orgId, params.projectId, params.envName)["secrets"][":name"].$get({ param: { name: params.name } })
       )
     ),
     create: withSchema(
       import_zod7.z.object({
+        orgId: import_zod7.z.string().describe("Organization slug"),
         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;
+        const { orgId, projectId, envName, name, description } = params;
         return call(
-          projEnv(projectId, envName)["secrets"].$post({ json: { kind: "Secret", name, description } })
+          projEnv(orgId, projectId, envName)["secrets"].$post({ json: { kind: "Secret", name, description } })
         );
       }
     ),
     delete: withSchema(
       import_zod7.z.object({
+        orgId: import_zod7.z.string().describe("Organization slug"),
         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 } })
+        projEnv(params.orgId, params.projectId, params.envName)["secrets"][":name"].$delete({ param: { name: params.name } })
       )
     ),
     setValue: withSchema(
       import_zod7.z.object({
+        orgId: import_zod7.z.string().describe("Organization slug"),
         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;
+        const { orgId, projectId, envName, name, value } = params;
         return call(
-          projEnv(projectId, envName)["secrets"][":name"]["value"].$put({
+          projEnv(orgId, projectId, envName)["secrets"][":name"]["value"].$put({
             param: { name },
             json: { value }
           })
@@ -921,12 +1030,13 @@ function createSecretsClient(projEnv) {
 function createApplyClient(projEnv) {
   return withSchema(
     import_types5.ApplyRequestSchema.extend({
+      orgId: import_zod7.z.string().describe("Organization slug"),
       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 }));
+      const { orgId, projectId, envName, ...body } = params;
+      return call(projEnv(orgId, projectId, envName)["apply"].$post({ json: body }));
     }
   );
 }
@@ -939,21 +1049,21 @@ function createGithubClient(cloud, _baseUrl, _hcOpts) {
       import_zod8.z.object({
         projectId: import_zod8.z.string().describe("Project ID")
       }),
-      (params) => call(cloud.api.github["install-url"].$post({ json: params }))
+      (params) => call(cloud.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 }))
+        (params) => call(cloud.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({
+          cloud.github.installations[":installationId"].repos.$get({
             param: params
           })
         )
@@ -963,7 +1073,7 @@ function createGithubClient(cloud, _baseUrl, _hcOpts) {
           installationId: import_zod8.z.string().describe("Installation row ID")
         }),
         (params) => call(
-          cloud.api.github.installations[":installationId"].$delete({
+          cloud.github.installations[":installationId"].$delete({
             param: params
           })
         )
@@ -973,7 +1083,7 @@ function createGithubClient(cloud, _baseUrl, _hcOpts) {
           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 }))
+        (params) => call(cloud.github.installations.recover.$post({ json: params }))
       )
     },
     projects: {
@@ -1034,12 +1144,13 @@ function stripServerFields(row) {
 function createExportCatalogFn(proj, projEnv) {
   return withSchema(
     import_zod9.z.object({
+      orgId: import_zod9.z.string().describe("Organization slug"),
       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 projClient = proj(params.orgId, params.projectId);
+      const envClient = projEnv(params.orgId, params.projectId, params.envName);
       const [entityTypes, cells, relationshipTypes, actions, secrets] = await Promise.all([
         call(projClient["entity-types"].$get()),
         call(projClient["cells"].$get()),
@@ -1079,32 +1190,35 @@ function createCatalogRevisionsClient(proj) {
   return {
     list: withSchema(
       import_zod10.z.object({
+        orgId: import_zod10.z.string().describe("Organization slug"),
         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;
+        const { orgId, projectId, ...query } = params;
         return call(
-          proj(projectId)["catalog-revisions"].$get({ query: stringifyQuery(query) })
+          proj(orgId, projectId)["catalog-revisions"].$get({ query: stringifyQuery(query) })
         );
       }
     ),
     get: withSchema(
       import_zod10.z.object({
+        orgId: import_zod10.z.string().describe("Organization slug"),
         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 } })
+        proj(params.orgId, params.projectId)["catalog-revisions"][":id"].$get({ param: { id: params.id } })
       )
     ),
     snapshots: withSchema(
       import_zod10.z.object({
+        orgId: import_zod10.z.string().describe("Organization slug"),
         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({
+        proj(params.orgId, params.projectId)["catalog-revisions"][":id"]["snapshots"].$get({
           param: { id: params.id }
         })
       )
@@ -1116,15 +1230,16 @@ function createCatalogRevisionsClient(proj) {
      */
     rollback: withSchema(
       import_zod10.z.object({
+        orgId: import_zod10.z.string().describe("Organization slug"),
         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;
+        const { orgId, projectId, id, hunkId, force } = params;
         return call(
-          proj(projectId)["catalog-revisions"][":id"]["rollback"].$post({
+          proj(orgId, projectId)["catalog-revisions"][":id"]["rollback"].$post({
             param: { id },
             json: { force: force ?? false },
             query: hunkId ? stringifyQuery({ hunkId }) : void 0
@@ -1141,6 +1256,7 @@ function createAuditEventsClient(proj) {
   return {
     list: withSchema(
       import_zod11.z.object({
+        orgId: import_zod11.z.string().describe("Organization slug"),
         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"),
@@ -1151,8 +1267,8 @@ function createAuditEventsClient(proj) {
         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) }));
+        const { orgId, projectId, ...query } = params;
+        return call(proj(orgId, projectId)["audit-events"].$get({ query: stringifyQuery(query) }));
       }
     )
   };
@@ -1164,27 +1280,30 @@ function createEnvironmentsClient(proj) {
   return {
     list: withSchema(
       import_zod12.z.object({
+        orgId: import_zod12.z.string().describe("Organization slug"),
         projectId: import_zod12.z.string().describe("Project ID")
       }),
-      (params) => call(proj(params.projectId)["environments"].$get())
+      (params) => call(proj(params.orgId, params.projectId)["environments"].$get())
     ),
     create: withSchema(
       import_zod12.z.object({
+        orgId: import_zod12.z.string().describe("Organization slug"),
         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 } }));
+        const { orgId, projectId, name } = params;
+        return call(proj(orgId, projectId)["environments"].$post({ json: { name } }));
       }
     ),
     delete: withSchema(
       import_zod12.z.object({
+        orgId: import_zod12.z.string().describe("Organization slug"),
         projectId: import_zod12.z.string().describe("Project ID"),
         name: import_zod12.z.string().describe("Environment name")
       }),
       (params) => call(
-        proj(params.projectId)["environments"][":envName"].$delete({
+        proj(params.orgId, params.projectId)["environments"][":envName"].$delete({
           param: { envName: params.name }
         })
       )
@@ -1198,6 +1317,7 @@ function createDriftEventsClient(projEnv) {
   return {
     list: withSchema(
       import_zod13.z.object({
+        orgId: import_zod13.z.string().describe("Organization slug"),
         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(),
@@ -1207,61 +1327,69 @@ function createDriftEventsClient(projEnv) {
         limit: import_zod13.z.coerce.number().int().min(1).max(500).optional()
       }),
       (params) => {
-        const { projectId, envName, ...query } = params;
+        const { orgId, projectId, envName, ...query } = params;
         return call(
-          projEnv(projectId, envName)["drift-events"].$get({ query: stringifyQuery(query) })
+          projEnv(orgId, 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())
+      import_zod13.z.object({
+        orgId: import_zod13.z.string().describe("Organization slug"),
+        projectId: import_zod13.z.string().describe("Project ID"),
+        envName: import_zod13.z.string().describe("Environment name")
+      }),
+      (params) => call(projEnv(params.orgId, params.projectId, params.envName)["drift-events"].count.$get())
     ),
     get: withSchema(
       import_zod13.z.object({
-        projectId: import_zod13.z.string(),
-        envName: import_zod13.z.string(),
+        orgId: import_zod13.z.string().describe("Organization slug"),
+        projectId: import_zod13.z.string().describe("Project ID"),
+        envName: import_zod13.z.string().describe("Environment name"),
         id: import_zod13.z.string().uuid()
       }),
       (params) => call(
-        projEnv(params.projectId, params.envName)["drift-events"][":id"].$get({
+        projEnv(params.orgId, 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(),
+        orgId: import_zod13.z.string().describe("Organization slug"),
+        projectId: import_zod13.z.string().describe("Project ID"),
+        envName: import_zod13.z.string().describe("Environment name"),
         id: import_zod13.z.string().uuid()
       }),
       (params) => call(
-        projEnv(params.projectId, params.envName)["drift-events"][":id"].accept.$post({
+        projEnv(params.orgId, 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(),
+        orgId: import_zod13.z.string().describe("Organization slug"),
+        projectId: import_zod13.z.string().describe("Project ID"),
+        envName: import_zod13.z.string().describe("Environment name"),
         id: import_zod13.z.string().uuid()
       }),
       (params) => call(
-        projEnv(params.projectId, params.envName)["drift-events"][":id"].reapply.$post({
+        projEnv(params.orgId, 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(),
+        orgId: import_zod13.z.string().describe("Organization slug"),
+        projectId: import_zod13.z.string().describe("Project ID"),
+        envName: import_zod13.z.string().describe("Environment name"),
         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({
+        projEnv(params.orgId, params.projectId, params.envName)["drift-events"][":id"].snooze.$post({
           param: { id: params.id },
           json: { untilSeconds: params.untilSeconds }
         })
@@ -1278,58 +1406,136 @@ function createStatsClient(proj) {
   return {
     entitiesByState: withSchema(
       import_zod14.z.object({
+        orgId: import_zod14.z.string().describe("Organization slug"),
         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) }));
+        const { orgId, projectId, ...query } = params;
+        return call(proj(orgId, projectId)["stats"]["entities-by-state"].$get({ query: stringifyQuery(query) }));
       }
     ),
     runsByType: withSchema(
       import_zod14.z.object({
+        orgId: import_zod14.z.string().describe("Organization slug"),
         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) }));
+        const { orgId, projectId, ...query } = params;
+        return call(proj(orgId, projectId)["stats"]["runs-by-type"].$get({ query: stringifyQuery(query) }));
       }
     ),
     failingKinds: withSchema(
       import_zod14.z.object({
+        orgId: import_zod14.z.string().describe("Organization slug"),
         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) }));
+        const { orgId, projectId, ...query } = params;
+        return call(proj(orgId, projectId)["stats"]["failing-kinds"].$get({ query: stringifyQuery(query) }));
       }
     ),
     driftDensity: withSchema(
       import_zod14.z.object({
+        orgId: import_zod14.z.string().describe("Organization slug"),
         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) }));
+        const { orgId, projectId, ...query } = params;
+        return call(proj(orgId, projectId)["stats"]["drift-density"].$get({ query: stringifyQuery(query) }));
       }
     )
   };
 }
 
-// src/notifications.ts
+// src/graph-views.ts
 var import_zod15 = require("zod");
+var ViewConfigSchema = import_zod15.z.unknown();
+var PinnedPositionsSchema = import_zod15.z.record(import_zod15.z.string(), import_zod15.z.object({ x: import_zod15.z.number(), y: import_zod15.z.number() })).nullable();
+function createGraphViewsClient(proj) {
+  return {
+    list: withSchema(
+      import_zod15.z.object({
+        orgId: import_zod15.z.string().describe("Organization slug"),
+        projectId: import_zod15.z.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.orgId, params.projectId)["graph-views"].$get())
+    ),
+    get: withSchema(
+      import_zod15.z.object({
+        orgId: import_zod15.z.string().describe("Organization slug"),
+        projectId: import_zod15.z.string().describe("Project ID"),
+        id: import_zod15.z.string().describe("View id")
+      }),
+      (params) => call(proj(params.orgId, params.projectId)["graph-views"][":id"].$get({ param: { id: params.id } }))
+    ),
+    create: withSchema(
+      import_zod15.z.object({
+        orgId: import_zod15.z.string().describe("Organization slug"),
+        projectId: import_zod15.z.string().describe("Project ID"),
+        name: import_zod15.z.string().describe("View name"),
+        scope: import_zod15.z.enum(["user", "project"]).describe("Personal or project scope"),
+        config: ViewConfigSchema.describe("ViewConfig JSON"),
+        pinnedPositions: PinnedPositionsSchema.optional().describe("Pinned node positions")
+      }),
+      (params) => {
+        const { orgId, projectId, ...body } = params;
+        return call(proj(orgId, projectId)["graph-views"].$post({ json: body }));
+      }
+    ),
+    update: withSchema(
+      import_zod15.z.object({
+        orgId: import_zod15.z.string().describe("Organization slug"),
+        projectId: import_zod15.z.string().describe("Project ID"),
+        id: import_zod15.z.string().describe("View id"),
+        name: import_zod15.z.string().optional().describe("New name"),
+        config: ViewConfigSchema.optional().describe("Replacement ViewConfig JSON"),
+        pinnedPositions: PinnedPositionsSchema.optional().describe("Replacement pinned positions")
+      }),
+      (params) => {
+        const { orgId, projectId, id, ...body } = params;
+        return call(
+          proj(orgId, projectId)["graph-views"][":id"].$put({ param: { id }, json: body })
+        );
+      }
+    ),
+    delete: withSchema(
+      import_zod15.z.object({
+        orgId: import_zod15.z.string().describe("Organization slug"),
+        projectId: import_zod15.z.string().describe("Project ID"),
+        id: import_zod15.z.string().describe("View id")
+      }),
+      (params) => call(proj(params.orgId, params.projectId)["graph-views"][":id"].$delete({ param: { id: params.id } }))
+    ),
+    setDefault: withSchema(
+      import_zod15.z.object({
+        orgId: import_zod15.z.string().describe("Organization slug"),
+        projectId: import_zod15.z.string().describe("Project ID"),
+        id: import_zod15.z.string().describe("View id")
+      }),
+      (params) => call(
+        proj(params.orgId, params.projectId)["graph-views"][":id"]["default"].$patch({
+          param: { id: params.id }
+        })
+      )
+    )
+  };
+}
+
+// src/notifications.ts
+var import_zod16 = require("zod");
 var import_client2 = require("hono/client");
 function createNotificationsClient(baseUrl, hcOpts) {
-  const c = (0, import_client2.hc)(`${baseUrl}/notifications`, hcOpts);
+  const c = (0, import_client2.hc)(`${baseUrl}/api/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()
+      import_zod16.z.object({
+        limit: import_zod16.z.coerce.number().int().min(1).max(100).optional(),
+        unread: import_zod16.z.boolean().optional()
       }),
       (params) => {
         const query = {};
@@ -1339,18 +1545,18 @@ function createNotificationsClient(baseUrl, hcOpts) {
       }
     ),
     read: withSchema(
-      import_zod15.z.object({ id: import_zod15.z.string().uuid() }),
+      import_zod16.z.object({ id: import_zod16.z.string().uuid() }),
       (params) => call(c[":id"].read.$post({ param: { id: params.id } }))
     ),
     readAll: withSchema(
-      import_zod15.z.object({}),
+      import_zod16.z.object({}),
       () => call(c["read-all"].$post())
     )
   };
 }
 
 // src/audit-export.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 async function rawRequest(baseUrl, hcOpts, path, init = {}) {
   const fetchImpl = hcOpts?.fetch ?? fetch;
   const rawHeaders = hcOpts?.headers;
@@ -1379,24 +1585,24 @@ 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") }),
+      import_zod17.z.object({ orgId: import_zod17.z.string().describe("Organization ID") }),
       async (params) => callRaw(
-        await rawRequest(baseUrl, hcOpts, `/orgs/${params.orgId}/audit-export/config`)
+        await rawRequest(baseUrl, hcOpts, `/api/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")
+      import_zod17.z.object({
+        orgId: import_zod17.z.string().describe("Organization ID"),
+        bucket: import_zod17.z.string().describe("S3 bucket name"),
+        region: import_zod17.z.string().describe("AWS region"),
+        roleArn: import_zod17.z.string().describe("IAM role ARN for assume-role"),
+        enabled: import_zod17.z.boolean().optional().describe("Enable/disable export")
       }),
       async (params) => {
         const { orgId, ...body } = params;
         return callRaw(
-          await rawRequest(baseUrl, hcOpts, `/orgs/${orgId}/audit-export/config`, {
+          await rawRequest(baseUrl, hcOpts, `/api/orgs/${orgId}/audit-export/config`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(body)
@@ -1406,16 +1612,16 @@ function createAuditExportClient(baseUrl, hcOpts) {
     ),
     /** 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")
+      import_zod17.z.object({
+        orgId: import_zod17.z.string().describe("Organization ID"),
+        bucket: import_zod17.z.string().describe("S3 bucket name"),
+        region: import_zod17.z.string().describe("AWS region"),
+        roleArn: import_zod17.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`, {
+          await rawRequest(baseUrl, hcOpts, `/api/orgs/${orgId}/audit-export/test-connection`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(body)
@@ -1425,9 +1631,9 @@ function createAuditExportClient(baseUrl, hcOpts) {
     ),
     /** 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)")
+      import_zod17.z.object({
+        orgId: import_zod17.z.string().describe("Organization ID"),
+        limit: import_zod17.z.number().optional().describe("Max results (default 20, max 100)")
       }),
       async (params) => {
         const qs = params.limit ? `?limit=${params.limit}` : "";
@@ -1435,7 +1641,7 @@ function createAuditExportClient(baseUrl, hcOpts) {
           await rawRequest(
             baseUrl,
             hcOpts,
-            `/orgs/${params.orgId}/audit-export/runs${qs}`
+            `/api/orgs/${params.orgId}/audit-export/runs${qs}`
           )
         );
       }
@@ -1447,7 +1653,7 @@ function createAuditExportClient(baseUrl, hcOpts) {
 var import_client3 = require("hono/client");
 function createUserPreferencesClient(baseUrl, hcOpts) {
   const c = (0, import_client3.hc)(
-    `${baseUrl}/user/preferences`,
+    `${baseUrl}/api/user/preferences`,
     hcOpts
   );
   return {
@@ -1463,47 +1669,53 @@ function createUserPreferencesClient(baseUrl, hcOpts) {
 }
 
 // src/import-sources.ts
-var import_zod17 = require("zod");
-var SourceKindEnum = import_zod17.z.enum(["tf-state", "atmos-manifests"]);
-var PolicyEnum = import_zod17.z.enum(["auto-update", "human-approval"]);
+var import_zod18 = require("zod");
+var SourceKindEnum = import_zod18.z.enum(["tf-state", "atmos-manifests"]);
+var PolicyEnum = import_zod18.z.enum(["auto-update", "human-approval"]);
 function createImportSourcesClient(proj) {
   return {
     list: withSchema(
-      import_zod17.z.object({ projectId: import_zod17.z.string().describe("Project ID") }),
-      (params) => call(proj(params.projectId)["import-sources"].$get())
+      import_zod18.z.object({
+        orgId: import_zod18.z.string().describe("Organization slug"),
+        projectId: import_zod18.z.string().describe("Project ID")
+      }),
+      (params) => call(proj(params.orgId, params.projectId)["import-sources"].$get())
     ),
     get: withSchema(
-      import_zod17.z.object({
-        projectId: import_zod17.z.string().describe("Project ID"),
-        id: import_zod17.z.string().uuid().describe("ImportSource ID")
+      import_zod18.z.object({
+        orgId: import_zod18.z.string().describe("Organization slug"),
+        projectId: import_zod18.z.string().describe("Project ID"),
+        id: import_zod18.z.string().uuid().describe("ImportSource ID")
       }),
-      (params) => call(proj(params.projectId)["import-sources"][":id"].$get({ param: { id: params.id } }))
+      (params) => call(proj(params.orgId, params.projectId)["import-sources"][":id"].$get({ param: { id: params.id } }))
     ),
     registerOrUpdate: withSchema(
-      import_zod17.z.object({
-        projectId: import_zod17.z.string().describe("Project ID"),
-        envName: import_zod17.z.string().describe("Env name the source belongs to"),
+      import_zod18.z.object({
+        orgId: import_zod18.z.string().describe("Organization slug"),
+        projectId: import_zod18.z.string().describe("Project ID"),
+        envName: import_zod18.z.string().describe("Env name the source belongs to"),
         sourceKind: SourceKindEnum,
-        sourceUri: import_zod17.z.string().describe("Stable URI identifying the source"),
+        sourceUri: import_zod18.z.string().describe("Stable URI identifying the source"),
         reconciliationPolicy: PolicyEnum.optional()
       }),
       (params) => {
-        const { projectId, ...body } = params;
-        return call(proj(projectId)["import-sources"].$post({ json: body }));
+        const { orgId, projectId, ...body } = params;
+        return call(proj(orgId, projectId)["import-sources"].$post({ json: body }));
       }
     ),
     rescan: withSchema(
-      import_zod17.z.object({
-        projectId: import_zod17.z.string(),
-        id: import_zod17.z.string().uuid(),
-        envName: import_zod17.z.string(),
-        items: import_zod17.z.array(import_zod17.z.unknown()),
-        deletions: import_zod17.z.array(import_zod17.z.object({ kind: import_zod17.z.string(), name: import_zod17.z.string() })).optional()
+      import_zod18.z.object({
+        orgId: import_zod18.z.string().describe("Organization slug"),
+        projectId: import_zod18.z.string().describe("Project ID"),
+        id: import_zod18.z.string().uuid(),
+        envName: import_zod18.z.string(),
+        items: import_zod18.z.array(import_zod18.z.unknown()),
+        deletions: import_zod18.z.array(import_zod18.z.object({ kind: import_zod18.z.string(), name: import_zod18.z.string() })).optional()
       }),
       (params) => {
-        const { projectId, id, ...body } = params;
+        const { orgId, projectId, id, ...body } = params;
         return call(
-          proj(projectId)["import-sources"][":id"].rescan.$post({
+          proj(orgId, projectId)["import-sources"][":id"].rescan.$post({
             param: { id },
             // why: the Hono RPC type for the body is the AnyKindSchema union;
             // the SDK accepts `unknown[]` so callers don't have to re-import the
@@ -1514,32 +1726,35 @@ function createImportSourcesClient(proj) {
       }
     ),
     drift: withSchema(
-      import_zod17.z.object({
-        projectId: import_zod17.z.string(),
-        id: import_zod17.z.string().uuid()
+      import_zod18.z.object({
+        orgId: import_zod18.z.string().describe("Organization slug"),
+        projectId: import_zod18.z.string().describe("Project ID"),
+        id: import_zod18.z.string().uuid()
       }),
-      (params) => call(proj(params.projectId)["import-sources"][":id"].drift.$get({ param: { id: params.id } }))
+      (params) => call(proj(params.orgId, params.projectId)["import-sources"][":id"].drift.$get({ param: { id: params.id } }))
     ),
     approveProposal: withSchema(
-      import_zod17.z.object({
-        projectId: import_zod17.z.string(),
-        id: import_zod17.z.string().uuid(),
-        proposalId: import_zod17.z.string().uuid()
+      import_zod18.z.object({
+        orgId: import_zod18.z.string().describe("Organization slug"),
+        projectId: import_zod18.z.string().describe("Project ID"),
+        id: import_zod18.z.string().uuid(),
+        proposalId: import_zod18.z.string().uuid()
       }),
       (params) => call(
-        proj(params.projectId)["import-sources"][":id"]["drift-proposals"][":proposalId"].approve.$post({
+        proj(params.orgId, params.projectId)["import-sources"][":id"]["drift-proposals"][":proposalId"].approve.$post({
           param: { id: params.id, proposalId: params.proposalId }
         })
       )
     ),
     rejectProposal: withSchema(
-      import_zod17.z.object({
-        projectId: import_zod17.z.string(),
-        id: import_zod17.z.string().uuid(),
-        proposalId: import_zod17.z.string().uuid()
+      import_zod18.z.object({
+        orgId: import_zod18.z.string().describe("Organization slug"),
+        projectId: import_zod18.z.string().describe("Project ID"),
+        id: import_zod18.z.string().uuid(),
+        proposalId: import_zod18.z.string().uuid()
       }),
       (params) => call(
-        proj(params.projectId)["import-sources"][":id"]["drift-proposals"][":proposalId"].reject.$post({
+        proj(params.orgId, params.projectId)["import-sources"][":id"]["drift-proposals"][":proposalId"].reject.$post({
           param: { id: params.id, proposalId: params.proposalId }
         })
       )
@@ -1548,7 +1763,7 @@ function createImportSourcesClient(proj) {
 }
 
 // src/admin.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 async function rawRequest2(baseUrl, hcOpts, path, init = {}) {
   const fetchImpl = hcOpts?.fetch ?? fetch;
   const rawHeaders = hcOpts?.headers;
@@ -1581,14 +1796,14 @@ function createAdminClient(baseUrl, hcOpts) {
        * List super-admin audit events with optional filters.
        */
       list: withSchema(
-        import_zod18.z.object({
-          actor: import_zod18.z.string().optional().describe("Filter by actor user ID"),
-          action: import_zod18.z.string().optional().describe("Filter by action name"),
-          resourceKind: import_zod18.z.string().optional().describe("Filter by resource kind"),
-          since: import_zod18.z.string().optional().describe("ISO 8601 datetime lower bound"),
-          until: import_zod18.z.string().optional().describe("ISO 8601 datetime upper bound"),
-          limit: import_zod18.z.coerce.number().int().min(1).max(200).optional().describe("Max results (1-200)"),
-          offset: import_zod18.z.coerce.number().int().min(0).optional().describe("Pagination offset")
+        import_zod19.z.object({
+          actor: import_zod19.z.string().optional().describe("Filter by actor user ID"),
+          action: import_zod19.z.string().optional().describe("Filter by action name"),
+          resourceKind: import_zod19.z.string().optional().describe("Filter by resource kind"),
+          since: import_zod19.z.string().optional().describe("ISO 8601 datetime lower bound"),
+          until: import_zod19.z.string().optional().describe("ISO 8601 datetime upper bound"),
+          limit: import_zod19.z.coerce.number().int().min(1).max(200).optional().describe("Max results (1-200)"),
+          offset: import_zod19.z.coerce.number().int().min(0).optional().describe("Pagination offset")
         }),
         async (params) => {
           const qs = new URLSearchParams();
@@ -1612,7 +1827,7 @@ function createAdminClient(baseUrl, hcOpts) {
        * List all organizations across tenants with member + project counts.
        */
       list: withSchema(
-        import_zod18.z.object({}),
+        import_zod19.z.object({}),
         async () => callRaw2(
           await rawRequest2(baseUrl, hcOpts, "/admin/orgs")
         )
@@ -1622,7 +1837,7 @@ function createAdminClient(baseUrl, hcOpts) {
        * Detail view: org fields + member list + project list.
        */
       get: withSchema(
-        import_zod18.z.object({ id: import_zod18.z.string().describe("Organization ID") }),
+        import_zod19.z.object({ id: import_zod19.z.string().describe("Organization ID") }),
         async (params) => callRaw2(
           await rawRequest2(baseUrl, hcOpts, `/admin/orgs/${params.id}`)
         )
@@ -1632,7 +1847,7 @@ function createAdminClient(baseUrl, hcOpts) {
        * Set suspended_at = now(). Idempotent.
        */
       suspend: withSchema(
-        import_zod18.z.object({ id: import_zod18.z.string().describe("Organization ID") }),
+        import_zod19.z.object({ id: import_zod19.z.string().describe("Organization ID") }),
         async (params) => callRaw2(
           await rawRequest2(baseUrl, hcOpts, `/admin/orgs/${params.id}/suspend`, {
             method: "POST"
@@ -1644,7 +1859,7 @@ function createAdminClient(baseUrl, hcOpts) {
        * Clear suspended_at.
        */
       unsuspend: withSchema(
-        import_zod18.z.object({ id: import_zod18.z.string().describe("Organization ID") }),
+        import_zod19.z.object({ id: import_zod19.z.string().describe("Organization ID") }),
         async (params) => callRaw2(
           await rawRequest2(baseUrl, hcOpts, `/admin/orgs/${params.id}/unsuspend`, {
             method: "POST"
@@ -1660,7 +1875,7 @@ function createAdminClient(baseUrl, hcOpts) {
        * api tokens, and environments. Idempotent. Super-admin only.
        */
       nuke: withSchema(
-        import_zod18.z.object({ projectId: import_zod18.z.string().describe("Project ID to nuke") }),
+        import_zod19.z.object({ projectId: import_zod19.z.string().describe("Project ID to nuke") }),
         async (params) => callRaw2(
           await rawRequest2(
             baseUrl,
@@ -1678,7 +1893,7 @@ function createAdminClient(baseUrl, hcOpts) {
        * all derived from single-table COUNT queries.
        */
       overview: withSchema(
-        import_zod18.z.object({}),
+        import_zod19.z.object({}),
         async () => callRaw2(
           await rawRequest2(baseUrl, hcOpts, "/admin/metrics/overview")
         )
@@ -1693,7 +1908,7 @@ function createAdminClient(baseUrl, hcOpts) {
          * Requires super-admin.
          */
         list: withSchema(
-          import_zod18.z.object({}),
+          import_zod19.z.object({}),
           async () => callRaw2(
             await rawRequest2(
               baseUrl,
@@ -1713,9 +1928,9 @@ var createClient = (baseUrl, 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 cloud = (0, import_client4.hc)(`${baseUrl}/api`, hcOpts);
+  const proj = (orgId, projectId) => (0, import_client4.hc)(`${baseUrl}/api/${orgId}/${projectId}`, hcOpts);
+  const projEnv = (orgId, projectId, envName) => (0, import_client4.hc)(`${baseUrl}/api/${orgId}/${projectId}/envs/${envName}`, hcOpts);
   const cells = createCellsClient(proj);
   const catalogRevisions = createCatalogRevisionsClient(proj);
   const exportCatalog = createExportCatalogFn(proj, projEnv);
@@ -1737,6 +1952,7 @@ var createClient = (baseUrl, options = {}) => {
     auditEvents: createAuditEventsClient(proj),
     driftEvents: createDriftEventsClient(projEnv),
     stats: createStatsClient(proj),
+    graphViews: createGraphViewsClient(proj),
     notifications: createNotificationsClient(baseUrl, hcOpts),
     auditExport: createAuditExportClient(baseUrl, hcOpts),
     userPreferences: createUserPreferencesClient(baseUrl, hcOpts),