lemma-sdk 0.2.0 → 0.2.2

package/dist/browser/lemma-client.js

@@ -31,17 +31,24 @@ const auth_js_1 = require("./auth.js");
 Object.defineProperty(exports, "AuthManager", { enumerable: true, get: function () { return auth_js_1.AuthManager; } });
 const generated_js_1 = require("./generated.js");
 const http_js_1 = require("./http.js");
+const agents_js_1 = require("./namespaces/agents.js");
+const assistants_js_1 = require("./namespaces/assistants.js");
 const datastores_js_1 = require("./namespaces/datastores.js");
-const tables_js_1 = require("./namespaces/tables.js");
-const records_js_1 = require("./namespaces/records.js");
+const desks_js_1 = require("./namespaces/desks.js");
 const files_js_1 = require("./namespaces/files.js");
 const functions_js_1 = require("./namespaces/functions.js");
-const agents_js_1 = require("./namespaces/agents.js");
+const icons_js_1 = require("./namespaces/icons.js");
+const integrations_js_1 = require("./namespaces/integrations.js");
+const organizations_js_1 = require("./namespaces/organizations.js");
+const pod_members_js_1 = require("./namespaces/pod-members.js");
+const pods_js_1 = require("./namespaces/pods.js");
+const pod_surfaces_js_1 = require("./namespaces/pod-surfaces.js");
+const records_js_1 = require("./namespaces/records.js");
+const resources_js_1 = require("./namespaces/resources.js");
+const tables_js_1 = require("./namespaces/tables.js");
 const tasks_js_1 = require("./namespaces/tasks.js");
-const assistants_js_1 = require("./namespaces/assistants.js");
+const users_js_1 = require("./namespaces/users.js");
 const workflows_js_1 = require("./namespaces/workflows.js");
-const desks_js_1 = require("./namespaces/desks.js");
-const integrations_js_1 = require("./namespaces/integrations.js");
 class LemmaClient {
     constructor(overrides = {}) {
         this._config = (0, config_js_1.resolveConfig)(overrides);
@@ -58,16 +65,23 @@ class LemmaClient {
         };
         this.datastores = new datastores_js_1.DatastoresNamespace(this._generated, podIdFn);
         this.tables = new tables_js_1.TablesNamespace(this._generated, podIdFn);
-        this.records = new records_js_1.RecordsNamespace(this._generated, podIdFn);
+        this.records = new records_js_1.RecordsNamespace(this._generated, this._http, podIdFn);
         this.files = new files_js_1.FilesNamespace(this._generated, this._http, podIdFn);
         this.functions = new functions_js_1.FunctionsNamespace(this._generated, podIdFn);
         this.agents = new agents_js_1.AgentsNamespace(this._generated, podIdFn);
-        this.tasks = new tasks_js_1.TasksNamespace(this._generated, podIdFn);
-        this.assistants = new assistants_js_1.AssistantsNamespace(this._generated, podIdFn);
-        this.conversations = new assistants_js_1.ConversationsNamespace(this._generated, podIdFn);
-        this.workflows = new workflows_js_1.WorkflowsNamespace(this._generated, podIdFn);
+        this.tasks = new tasks_js_1.TasksNamespace(this._http, podIdFn);
+        this.assistants = new assistants_js_1.AssistantsNamespace(this._http, podIdFn);
+        this.conversations = new assistants_js_1.ConversationsNamespace(this._http, podIdFn);
+        this.workflows = new workflows_js_1.WorkflowsNamespace(this._generated, this._http, podIdFn);
         this.desks = new desks_js_1.DesksNamespace(this._generated, this._http, podIdFn);
         this.integrations = new integrations_js_1.IntegrationsNamespace(this._generated);
+        this.resources = new resources_js_1.ResourcesNamespace(this._http);
+        this.users = new users_js_1.UsersNamespace(this._generated);
+        this.icons = new icons_js_1.IconsNamespace(this._generated);
+        this.pods = new pods_js_1.PodsNamespace(this._generated, this._http);
+        this.podMembers = new pod_members_js_1.PodMembersNamespace(this._generated);
+        this.organizations = new organizations_js_1.OrganizationsNamespace(this._generated, this._http);
+        this.podSurfaces = new pod_surfaces_js_1.PodSurfacesNamespace(this._generated);
     }
     /** Change the active pod ID for subsequent calls. */
     setPodId(podId) {
@@ -479,6 +493,35 @@ class HttpClient {
         this.apiUrl = apiUrl;
         this.auth = auth;
     }
+    getBaseUrl() {
+        return this.apiUrl;
+    }
+    buildUrl(path, params) {
+        let url = `${this.apiUrl}${path}`;
+        if (!params) {
+            return url;
+        }
+        const qs = Object.entries(params)
+            .filter(([, value]) => value !== undefined && value !== null)
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
+            .join("&");
+        if (qs) {
+            url += `?${qs}`;
+        }
+        return url;
+    }
+    mergeHeaders(base, extra) {
+        if (!extra) {
+            return base;
+        }
+        const merged = new Headers(base.headers ?? {});
+        const extraHeaders = new Headers(extra);
+        extraHeaders.forEach((value, key) => merged.set(key, value));
+        return {
+            ...base,
+            headers: merged,
+        };
+    }
     async parseError(response) {
         let message = response.statusText || "Request failed";
         let code;
@@ -488,9 +531,14 @@ class HttpClient {
             const body = await response.json();
             raw = body;
             if (body && typeof body === "object") {
-                message = body.message ?? message;
-                code = body.code;
-                details = body.details;
+                const record = body;
+                if (typeof record.message === "string") {
+                    message = record.message;
+                }
+                if (typeof record.code === "string") {
+                    code = record.code;
+                }
+                details = record.details;
             }
         }
         catch {
@@ -498,31 +546,33 @@ class HttpClient {
         }
         return new ApiError(response.status, message, code, details, raw);
     }
-    async request(method, path, options = {}) {
-        let url = `${this.apiUrl}${path}`;
-        if (options.params) {
-            const qs = Object.entries(options.params)
-                .filter(([, v]) => v !== undefined && v !== null)
-                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
-                .join("&");
-            if (qs) {
-                url += `?${qs}`;
-            }
-        }
-        const initBase = { method };
-        if (options.body !== undefined && !options.isFormData) {
-            initBase.body = JSON.stringify(options.body);
+    getRequestBody(options) {
+        if (options.body === undefined) {
+            return undefined;
         }
-        else if (options.isFormData && options.body instanceof FormData) {
-            initBase.body = options.body;
+        if (options.isFormData && options.body instanceof FormData) {
+            return options.body;
         }
-        // For FormData, let the browser set Content-Type with boundary
-        const init = options.isFormData
+        return JSON.stringify(options.body);
+    }
+    buildRequestInit(method, options) {
+        const initBase = {
+            method,
+            body: this.getRequestBody(options),
+            signal: options.signal,
+        };
+        // For FormData, let the browser set Content-Type with boundary.
+        const withAuth = options.isFormData
             ? {
                 ...this.auth.getRequestInit(initBase),
-                headers: Object.fromEntries(Object.entries(this.auth.getRequestInit(initBase).headers ?? {}).filter(([k]) => k.toLowerCase() !== "content-type")),
+                headers: Object.fromEntries(Object.entries(this.auth.getRequestInit(initBase).headers ?? {}).filter(([key]) => key.toLowerCase() !== "content-type")),
             }
             : this.auth.getRequestInit(initBase);
+        return this.mergeHeaders(withAuth, options.headers);
+    }
+    async request(method, path, options = {}) {
+        const url = this.buildUrl(path, options.params);
+        const init = this.buildRequestInit(method, options);
         const response = await fetch(url, init);
         // Only 401 means the session is gone — 403 is a permission/RLS error, not an auth failure
         if (response.status === 401) {
@@ -540,6 +590,25 @@ class HttpClient {
         }
         return response.text();
     }
+    async stream(path, options = {}) {
+        const response = await fetch(this.buildUrl(path, options.params), this.buildRequestInit(options.method ?? "GET", {
+            ...options,
+            headers: {
+                Accept: "text/event-stream",
+                ...options.headers,
+            },
+        }));
+        if (response.status === 401) {
+            this.auth.markUnauthenticated();
+        }
+        if (!response.ok) {
+            throw await this.parseError(response);
+        }
+        if (!response.body) {
+            throw new ApiError(response.status, "Stream response had no body.");
+        }
+        return response.body;
+    }
     async requestBytes(method, path) {
         const url = `${this.apiUrl}${path}`;
         const response = await fetch(url, this.auth.getRequestInit({ method }));
@@ -590,58 +659,54 @@ exports.OpenAPI = {
 };
 
 },
-"./namespaces/datastores.js": function (module, exports, require) {
+"./namespaces/agents.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatastoresNamespace = void 0;
-const DatastoreService_js_1 = require("./openapi_client/services/DatastoreService.js");
-class DatastoresNamespace {
+exports.AgentsNamespace = void 0;
+const AgentsService_js_1 = require("./openapi_client/services/AgentsService.js");
+class AgentsNamespace {
     constructor(client, podId) {
         this.client = client;
         this.podId = podId;
     }
     list(options = {}) {
-        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreList(this.podId(), options.limit ?? 100, options.pageToken));
+        return this.client.request(() => AgentsService_js_1.AgentsService.agentList(this.podId(), options.limit ?? 100, options.pageToken));
     }
     create(payload) {
-        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreCreate(this.podId(), payload));
-    }
-    get(name) {
-        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreGet(this.podId(), name));
+        return this.client.request(() => AgentsService_js_1.AgentsService.agentCreate(this.podId(), payload));
     }
-    update(name, payload) {
-        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreUpdate(this.podId(), name, payload));
+    get(agentName) {
+        return this.client.request(() => AgentsService_js_1.AgentsService.agentGet(this.podId(), agentName));
     }
-    delete(name) {
-        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreDelete(this.podId(), name));
+    update(agentName, payload) {
+        return this.client.request(() => AgentsService_js_1.AgentsService.agentUpdate(this.podId(), agentName, payload));
     }
-    query(name, request) {
-        const payload = typeof request === "string" ? { query: request } : request;
-        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreQuery(this.podId(), name, payload));
+    delete(agentName) {
+        return this.client.request(() => AgentsService_js_1.AgentsService.agentDelete(this.podId(), agentName));
     }
 }
-exports.DatastoresNamespace = DatastoresNamespace;
+exports.AgentsNamespace = AgentsNamespace;
 
 },
-"./openapi_client/services/DatastoreService.js": function (module, exports, require) {
+"./openapi_client/services/AgentsService.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatastoreService = void 0;
+exports.AgentsService = void 0;
 const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
 const request_js_1 = require("./openapi_client/core/request.js");
-class DatastoreService {
+class AgentsService {
     /**
-     * Create Datastore
-     * Create a datastore namespace inside a pod. Use this before creating tables. Datastore names are normalized for stable API paths.
+     * Create Agent
+     * Create a new agent in a pod
      * @param podId
      * @param requestBody
-     * @returns DatastoreResponse Successful Response
+     * @returns AgentResponse Successful Response
      * @throws ApiError
      */
-    static datastoreCreate(podId, requestBody) {
+    static agentCreate(podId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/datastores',
+            url: '/pods/{pod_id}/agents',
             path: {
                 'pod_id': podId,
             },
@@ -653,18 +718,18 @@ class DatastoreService {
         });
     }
     /**
-     * List Datastores
-     * List datastores available in the pod.
+     * List Agents
+     * List all agents in a pod
      * @param podId
-     * @param limit Max number of datastores to return.
-     * @param pageToken Cursor from a previous response to fetch the next page.
-     * @returns DatastoreListResponse Successful Response
+     * @param limit
+     * @param pageToken
+     * @returns AgentListResponse Successful Response
      * @throws ApiError
      */
-    static datastoreList(podId, limit = 100, pageToken) {
+    static agentList(podId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/datastores',
+            url: '/pods/{pod_id}/agents',
             path: {
                 'pod_id': podId,
             },
@@ -678,20 +743,20 @@ class DatastoreService {
         });
     }
     /**
-     * Get Datastore
-     * Get datastore metadata by datastore name.
+     * Get Agent
+     * Get an agent by name
      * @param podId
-     * @param datastoreName
-     * @returns DatastoreResponse Successful Response
+     * @param agentName
+     * @returns AgentResponse Successful Response
      * @throws ApiError
      */
-    static datastoreGet(podId, datastoreName) {
+    static agentGet(podId, agentName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/datastores/{datastore_name}',
+            url: '/pods/{pod_id}/agents/{agent_name}',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
+                'agent_name': agentName,
             },
             errors: {
                 422: `Validation Error`,
@@ -699,21 +764,21 @@ class DatastoreService {
         });
     }
     /**
-     * Update Datastore
-     * Update datastore metadata and event emission settings.
+     * Update Agent
+     * Update an agent
      * @param podId
-     * @param datastoreName
+     * @param agentName
      * @param requestBody
-     * @returns DatastoreResponse Successful Response
+     * @returns AgentResponse Successful Response
      * @throws ApiError
      */
-    static datastoreUpdate(podId, datastoreName, requestBody) {
+    static agentUpdate(podId, agentName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'PATCH',
-            url: '/pods/{pod_id}/datastores/{datastore_name}',
+            url: '/pods/{pod_id}/agents/{agent_name}',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
+                'agent_name': agentName,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -723,52 +788,28 @@ class DatastoreService {
         });
     }
     /**
-     * Delete Datastore
-     * Delete a datastore and its underlying resources.
+     * Delete Agent
+     * Delete an agent
      * @param podId
-     * @param datastoreName
-     * @returns DatastoreMessageResponse Successful Response
+     * @param agentName
+     * @returns AgentMessageResponse Successful Response
      * @throws ApiError
      */
-    static datastoreDelete(podId, datastoreName) {
+    static agentDelete(podId, agentName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'DELETE',
-            url: '/pods/{pod_id}/datastores/{datastore_name}',
-            path: {
-                'pod_id': podId,
-                'datastore_name': datastoreName,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Execute Query
-     * Execute a read-only SQL query in the datastore schema. Mutating statements (`INSERT`, `UPDATE`, `DELETE`, `DROP`, etc.) are blocked.
-     * @param podId
-     * @param datastoreName
-     * @param requestBody
-     * @returns RecordQueryResponse Successful Response
-     * @throws ApiError
-     */
-    static datastoreQuery(podId, datastoreName, requestBody) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/query',
+            url: '/pods/{pod_id}/agents/{agent_name}',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
+                'agent_name': agentName,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
 }
-exports.DatastoreService = DatastoreService;
+exports.AgentsService = AgentsService;
 
 },
 "./openapi_client/core/request.js": function (module, exports, require) {
@@ -1187,65 +1228,221 @@ class CancelablePromise {
 exports.CancelablePromise = CancelablePromise;
 
 },
-"./namespaces/tables.js": function (module, exports, require) {
+"./namespaces/assistants.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TablesNamespace = void 0;
-const TablesService_js_1 = require("./openapi_client/services/TablesService.js");
-class TablesNamespace {
-    constructor(client, podId) {
-        this.client = client;
+exports.ConversationsNamespace = exports.AssistantsNamespace = void 0;
+class AssistantsNamespace {
+    constructor(http, podId) {
+        this.http = http;
         this.podId = podId;
-        this.columns = {
-            add: (datastore, tableName, request) => {
-                const payload = "column" in request ? request : { column: request };
-                return this.client.request(() => TablesService_js_1.TablesService.tableColumnAdd(this.podId(), datastore, tableName, payload));
+    }
+    list(options = {}) {
+        return this.http.request("GET", `/pods/${this.podId()}/assistants`, {
+            params: {
+                limit: options.limit ?? 100,
+                page_token: options.pageToken ?? options.cursor,
+                cursor: options.cursor,
             },
-            remove: (datastore, tableName, columnName) => this.client.request(() => TablesService_js_1.TablesService.tableColumnRemove(this.podId(), datastore, tableName, columnName)),
+        });
+    }
+    create(payload) {
+        return this.http.request("POST", `/pods/${this.podId()}/assistants`, { body: payload });
+    }
+    get(assistantName) {
+        return this.http.request("GET", `/pods/${this.podId()}/assistants/${assistantName}`);
+    }
+    update(assistantName, payload) {
+        return this.http.request("PATCH", `/pods/${this.podId()}/assistants/${assistantName}`, {
+            body: payload,
+        });
+    }
+    delete(assistantName) {
+        return this.http.request("DELETE", `/pods/${this.podId()}/assistants/${assistantName}`);
+    }
+}
+exports.AssistantsNamespace = AssistantsNamespace;
+class ConversationsNamespace {
+    constructor(http, podId) {
+        this.http = http;
+        this.podId = podId;
+        this.messages = {
+            list: (conversationId, options = {}) => this.http.request("GET", `/conversations/${conversationId}/messages`, {
+                params: {
+                    pod_id: this.resolvePodId(options.podId),
+                    limit: options.limit ?? 20,
+                    page_token: options.pageToken ?? options.cursor,
+                    cursor: options.cursor,
+                    order: options.order,
+                },
+            }),
+            send: (conversationId, payload, options = {}) => this.http.request("POST", `/conversations/${conversationId}/messages`, {
+                params: {
+                    pod_id: this.resolvePodId(options.podId),
+                },
+                body: payload,
+            }),
         };
     }
-    list(datastore, options = {}) {
-        return this.client.request(() => TablesService_js_1.TablesService.tableList(this.podId(), datastore, options.limit ?? 100, options.pageToken));
+    resolvePodId(explicitPodId) {
+        if (typeof explicitPodId === "string") {
+            return explicitPodId;
+        }
+        try {
+            return this.podId();
+        }
+        catch {
+            return undefined;
+        }
     }
-    create(datastore, payload) {
-        return this.client.request(() => TablesService_js_1.TablesService.tableCreate(this.podId(), datastore, payload));
+    requirePodId(explicitPodId) {
+        const podId = this.resolvePodId(explicitPodId);
+        if (!podId) {
+            throw new Error("pod_id is required for this conversation operation.");
+        }
+        return podId;
     }
-    get(datastore, tableName) {
-        return this.client.request(() => TablesService_js_1.TablesService.tableGet(this.podId(), datastore, tableName));
+    list(options = {}) {
+        return this.http.request("GET", "/conversations", {
+            params: {
+                assistant_id: options.assistantName ?? options.assistantId,
+                pod_id: this.resolvePodId(options.podId),
+                organization_id: options.organizationId,
+                limit: options.limit ?? 20,
+                page_token: options.pageToken ?? options.cursor,
+                cursor: options.cursor,
+            },
+        });
     }
-    update(datastore, tableName, payload) {
-        return this.client.request(() => TablesService_js_1.TablesService.tableUpdate(this.podId(), datastore, tableName, payload));
+    listByAssistant(assistantName, options = {}) {
+        return this.list({ ...options, assistantName });
     }
-    delete(datastore, tableName) {
-        return this.client.request(() => TablesService_js_1.TablesService.tableDelete(this.podId(), datastore, tableName));
+    create(payload) {
+        return this.http.request("POST", "/conversations", {
+            body: {
+                ...payload,
+                assistant_id: payload.assistant_id ?? payload.assistant_name,
+                pod_id: this.resolvePodId(payload.pod_id),
+            },
+        });
+    }
+    createForAssistant(assistantName, payload = {}) {
+        return this.create({
+            ...payload,
+            assistant_name: assistantName,
+            pod_id: payload.pod_id,
+        });
+    }
+    get(conversationId, options = {}) {
+        return this.http.request("GET", `/conversations/${conversationId}`, {
+            params: {
+                pod_id: this.resolvePodId(options.podId),
+            },
+        });
+    }
+    update(conversationId, payload, options = {}) {
+        return this.http.request("PATCH", `/conversations/${conversationId}`, {
+            params: {
+                pod_id: this.resolvePodId(options.podId),
+            },
+            body: payload,
+        });
+    }
+    delete(conversationId, options = {}) {
+        const scopedPodId = this.requirePodId(options.podId);
+        return this.http.request("DELETE", `/pods/${scopedPodId}/conversations/${conversationId}`);
+    }
+    sendMessageStream(conversationId, payload, options = {}) {
+        return this.http.stream(`/conversations/${conversationId}/messages`, {
+            method: "POST",
+            params: {
+                pod_id: this.resolvePodId(options.podId),
+            },
+            body: payload,
+            signal: options.signal,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+            },
+        });
+    }
+    resumeStream(conversationId, options = {}) {
+        return this.http.stream(`/conversations/${conversationId}/stream`, {
+            params: {
+                pod_id: this.resolvePodId(options.podId),
+            },
+            signal: options.signal,
+            headers: {
+                Accept: "text/event-stream",
+            },
+        });
+    }
+    stopRun(conversationId, options = {}) {
+        return this.http.request("PATCH", `/conversations/${conversationId}/stop`, {
+            params: {
+                pod_id: this.resolvePodId(options.podId),
+            },
+            body: {},
+        });
     }
 }
-exports.TablesNamespace = TablesNamespace;
+exports.ConversationsNamespace = ConversationsNamespace;
 
 },
-"./openapi_client/services/TablesService.js": function (module, exports, require) {
+"./namespaces/datastores.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TablesService = void 0;
+exports.DatastoresNamespace = void 0;
+const DatastoreService_js_1 = require("./openapi_client/services/DatastoreService.js");
+class DatastoresNamespace {
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreCreate(this.podId(), payload));
+    }
+    get(name) {
+        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreGet(this.podId(), name));
+    }
+    update(name, payload) {
+        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreUpdate(this.podId(), name, payload));
+    }
+    delete(name) {
+        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreDelete(this.podId(), name));
+    }
+    query(name, request) {
+        const payload = typeof request === "string" ? { query: request } : request;
+        return this.client.request(() => DatastoreService_js_1.DatastoreService.datastoreQuery(this.podId(), name, payload));
+    }
+}
+exports.DatastoresNamespace = DatastoresNamespace;
+
+},
+"./openapi_client/services/DatastoreService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatastoreService = void 0;
 const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
 const request_js_1 = require("./openapi_client/core/request.js");
-class TablesService {
+class DatastoreService {
     /**
-     * Create Table
-     * Create a table in a datastore. Define primary key, column schema, and optional RLS behavior.
+     * Create Datastore
+     * Create a datastore namespace inside a pod. Use this before creating tables. Datastore names are normalized for stable API paths.
      * @param podId
-     * @param datastoreName
      * @param requestBody
-     * @returns TableResponse Successful Response
+     * @returns DatastoreResponse Successful Response
      * @throws ApiError
      */
-    static tableCreate(podId, datastoreName, requestBody) {
+    static datastoreCreate(podId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables',
+            url: '/pods/{pod_id}/datastores',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -1255,22 +1452,20 @@ class TablesService {
         });
     }
     /**
-     * List Tables
-     * List tables in a datastore.
+     * List Datastores
+     * List datastores available in the pod.
      * @param podId
-     * @param datastoreName
-     * @param limit Max number of tables to return.
-     * @param pageToken Cursor from a previous response for pagination.
-     * @returns TableListResponse Successful Response
+     * @param limit Max number of datastores to return.
+     * @param pageToken Cursor from a previous response to fetch the next page.
+     * @returns DatastoreListResponse Successful Response
      * @throws ApiError
      */
-    static tableList(podId, datastoreName, limit = 100, pageToken) {
+    static datastoreList(podId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables',
+            url: '/pods/{pod_id}/datastores',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
             },
             query: {
                 'limit': limit,
@@ -1282,45 +1477,20 @@ class TablesService {
         });
     }
     /**
-     * Get Table
-     * Get table schema metadata by table name.
+     * Get Datastore
+     * Get datastore metadata by datastore name.
      * @param podId
      * @param datastoreName
-     * @param tableName
-     * @returns TableResponse Successful Response
+     * @returns DatastoreResponse Successful Response
      * @throws ApiError
      */
-    static tableGet(podId, datastoreName, tableName) {
+    static datastoreGet(podId, datastoreName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}',
-            path: {
-                'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Delete Table
-     * Delete a table and all records in it.
-     * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @returns DatastoreMessageResponse Successful Response
-     * @throws ApiError
-     */
-    static tableDelete(podId, datastoreName, tableName) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'DELETE',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}',
+            url: '/pods/{pod_id}/datastores/{datastore_name}',
             path: {
                 'pod_id': podId,
                 'datastore_name': datastoreName,
-                'table_name': tableName,
             },
             errors: {
                 422: `Validation Error`,
@@ -1328,23 +1498,21 @@ class TablesService {
         });
     }
     /**
-     * Update Table
-     * Update table metadata/configuration payload.
+     * Update Datastore
+     * Update datastore metadata and event emission settings.
      * @param podId
      * @param datastoreName
-     * @param tableName
      * @param requestBody
-     * @returns TableResponse Successful Response
+     * @returns DatastoreResponse Successful Response
      * @throws ApiError
      */
-    static tableUpdate(podId, datastoreName, tableName, requestBody) {
+    static datastoreUpdate(podId, datastoreName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'PATCH',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}',
+            url: '/pods/{pod_id}/datastores/{datastore_name}',
             path: {
                 'pod_id': podId,
                 'datastore_name': datastoreName,
-                'table_name': tableName,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -1354,136 +1522,113 @@ class TablesService {
         });
     }
     /**
-     * Add Column
-     * Add a new column to a table. Column names must be unique and compatible with existing table schema rules.
+     * Delete Datastore
+     * Delete a datastore and its underlying resources.
      * @param podId
      * @param datastoreName
-     * @param tableName
-     * @param requestBody
-     * @returns TableResponse Successful Response
+     * @returns DatastoreMessageResponse Successful Response
      * @throws ApiError
      */
-    static tableColumnAdd(podId, datastoreName, tableName, requestBody) {
+    static datastoreDelete(podId, datastoreName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/columns',
+            method: 'DELETE',
+            url: '/pods/{pod_id}/datastores/{datastore_name}',
             path: {
                 'pod_id': podId,
                 'datastore_name': datastoreName,
-                'table_name': tableName,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Remove Column
-     * Remove a non-primary, non-system column from a table. System columns and the primary key cannot be removed.
+     * Execute Query
+     * Execute a read-only SQL query in the datastore schema. Mutating statements (`INSERT`, `UPDATE`, `DELETE`, `DROP`, etc.) are blocked.
      * @param podId
      * @param datastoreName
-     * @param tableName
-     * @param columnName
-     * @returns DatastoreMessageResponse Successful Response
+     * @param requestBody
+     * @returns RecordQueryResponse Successful Response
      * @throws ApiError
      */
-    static tableColumnRemove(podId, datastoreName, tableName, columnName) {
+    static datastoreQuery(podId, datastoreName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'DELETE',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/columns/{column_name}',
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/query',
             path: {
                 'pod_id': podId,
                 'datastore_name': datastoreName,
-                'table_name': tableName,
-                'column_name': columnName,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
 }
-exports.TablesService = TablesService;
+exports.DatastoreService = DatastoreService;
 
 },
-"./namespaces/records.js": function (module, exports, require) {
+"./namespaces/desks.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecordsNamespace = void 0;
-const RecordsService_js_1 = require("./openapi_client/services/RecordsService.js");
-class RecordsNamespace {
-    constructor(client, podId) {
+exports.DesksNamespace = void 0;
+const DesksService_js_1 = require("./openapi_client/services/DesksService.js");
+class DesksNamespace {
+    constructor(client, http, podId) {
         this.client = client;
+        this.http = http;
         this.podId = podId;
-        this.bulk = {
-            create: (datastore, table, records) => {
-                const payload = { records };
-                return this.client.request(() => RecordsService_js_1.RecordsService.recordBulkCreate(this.podId(), datastore, table, payload));
-            },
-            update: (datastore, table, records) => {
-                const payload = { records };
-                return this.client.request(() => RecordsService_js_1.RecordsService.recordBulkUpdate(this.podId(), datastore, table, payload));
-            },
-            delete: (datastore, table, recordIds) => {
-                const payload = { record_ids: recordIds };
-                return this.client.request(() => RecordsService_js_1.RecordsService.recordBulkDelete(this.podId(), datastore, table, payload));
-            },
+        this.html = {
+            get: (name) => this.client.request(() => DesksService_js_1.DesksService.podDeskHtmlGet(this.podId(), name)),
+        };
+        this.bundle = {
+            upload: (name, payload) => this.client.request(() => DesksService_js_1.DesksService.podDeskBundleUpload(this.podId(), name, payload)),
+        };
+        this.source = {
+            download: (name) => this.http.requestBytes("GET", `/pods/${this.podId()}/desks/${name}/source/archive`),
         };
     }
-    list(datastore, table, options = {}) {
-        const { filters, sort, limit, pageToken } = options;
-        if (filters || sort) {
-            const payload = { filters, sort, limit, page_token: pageToken };
-            return this.client.request(() => RecordsService_js_1.RecordsService.recordQuery(this.podId(), datastore, table, payload));
-        }
-        return this.client.request(() => RecordsService_js_1.RecordsService.recordList(this.podId(), datastore, table, limit ?? 20, pageToken));
-    }
-    create(datastore, table, data) {
-        return this.client.request(() => RecordsService_js_1.RecordsService.recordCreate(this.podId(), datastore, table, { data }));
+    list(options = {}) {
+        return this.client.request(() => DesksService_js_1.DesksService.podDeskList(this.podId(), options.limit ?? 100, options.pageToken));
     }
-    get(datastore, table, recordId) {
-        return this.client.request(() => RecordsService_js_1.RecordsService.recordGet(this.podId(), datastore, table, recordId));
+    create(payload) {
+        return this.client.request(() => DesksService_js_1.DesksService.podDeskCreate(this.podId(), payload));
     }
-    update(datastore, table, recordId, data) {
-        return this.client.request(() => RecordsService_js_1.RecordsService.recordUpdate(this.podId(), datastore, table, recordId, { data }));
+    get(name) {
+        return this.client.request(() => DesksService_js_1.DesksService.podDeskGet(this.podId(), name));
     }
-    delete(datastore, table, recordId) {
-        return this.client.request(() => RecordsService_js_1.RecordsService.recordDelete(this.podId(), datastore, table, recordId));
+    update(name, payload) {
+        return this.client.request(() => DesksService_js_1.DesksService.podDeskUpdate(this.podId(), name, payload));
     }
-    query(datastore, table, payload) {
-        return this.client.request(() => RecordsService_js_1.RecordsService.recordQuery(this.podId(), datastore, table, payload));
+    delete(name) {
+        return this.client.request(() => DesksService_js_1.DesksService.podDeskDelete(this.podId(), name));
     }
 }
-exports.RecordsNamespace = RecordsNamespace;
+exports.DesksNamespace = DesksNamespace;
 
 },
-"./openapi_client/services/RecordsService.js": function (module, exports, require) {
+"./openapi_client/services/DesksService.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecordsService = void 0;
+exports.DesksService = void 0;
 const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
 const request_js_1 = require("./openapi_client/core/request.js");
-class RecordsService {
+class DesksService {
     /**
-     * Create Record
-     * Insert a record into a table. Reserved tables (`reserved_*`) are system-managed and cannot be mutated through record write endpoints.
+     * Create Desk
      * @param podId
-     * @param datastoreName
-     * @param tableName
      * @param requestBody
-     * @returns RecordResponse Successful Response
+     * @returns DeskResponse Successful Response
      * @throws ApiError
      */
-    static recordCreate(podId, datastoreName, tableName, requestBody) {
+    static podDeskCreate(podId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records',
+            url: '/pods/{pod_id}/desks',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -1493,24 +1638,19 @@ class RecordsService {
         });
     }
     /**
-     * List Records
-     * List table records with token pagination only. Use `record.query` when you need structured filters or explicit sort clauses.
+     * List Desks
      * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param limit Max number of rows to return.
-     * @param pageToken Opaque token from a previous response page.
-     * @returns RecordListResponse Successful Response
+     * @param limit
+     * @param pageToken
+     * @returns DeskListResponse Successful Response
      * @throws ApiError
      */
-    static recordList(podId, datastoreName, tableName, limit = 20, pageToken) {
+    static podDeskList(podId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records',
+            url: '/pods/{pod_id}/desks',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
             },
             query: {
                 'limit': limit,
@@ -1522,24 +1662,19 @@ class RecordsService {
         });
     }
     /**
-     * Get Record
-     * Fetch one record by primary key value. The `record_id` path segment is the table's primary key value as stored in the table, not necessarily a UUID.
+     * Get Desk
      * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param recordId
-     * @returns RecordResponse Successful Response
+     * @param deskName
+     * @returns DeskResponse Successful Response
      * @throws ApiError
      */
-    static recordGet(podId, datastoreName, tableName, recordId) {
+    static podDeskGet(podId, deskName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/{record_id}',
+            url: '/pods/{pod_id}/desks/{desk_name}',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
-                'record_id': recordId,
+                'desk_name': deskName,
             },
             errors: {
                 422: `Validation Error`,
@@ -1547,25 +1682,20 @@ class RecordsService {
         });
     }
     /**
-     * Update Record
-     * Patch a record by primary key.
+     * Update Desk
      * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param recordId
+     * @param deskName
      * @param requestBody
-     * @returns RecordResponse Successful Response
+     * @returns DeskResponse Successful Response
      * @throws ApiError
      */
-    static recordUpdate(podId, datastoreName, tableName, recordId, requestBody) {
+    static podDeskUpdate(podId, deskName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'PATCH',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/{record_id}',
+            url: '/pods/{pod_id}/desks/{desk_name}',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
-                'record_id': recordId,
+                'desk_name': deskName,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -1575,136 +1705,90 @@ class RecordsService {
         });
     }
     /**
-     * Delete Record
-     * Delete a record by primary key.
+     * Delete Desk
      * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param recordId
-     * @returns DatastoreMessageResponse Successful Response
+     * @param deskName
+     * @returns DeskMessageResponse Successful Response
      * @throws ApiError
      */
-    static recordDelete(podId, datastoreName, tableName, recordId) {
+    static podDeskDelete(podId, deskName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'DELETE',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/{record_id}',
-            path: {
-                'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
-                'record_id': recordId,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Bulk Create
-     * Insert multiple records in one request.
-     * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param requestBody
-     * @returns DatastoreMessageResponse Successful Response
-     * @throws ApiError
-     */
-    static recordBulkCreate(podId, datastoreName, tableName, requestBody) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/bulk/create',
+            url: '/pods/{pod_id}/desks/{desk_name}',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
+                'desk_name': deskName,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Bulk Update
-     * Update multiple records in one request (each item needs primary key).
+     * Upload Desk Bundle
      * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param requestBody
-     * @returns DatastoreMessageResponse Successful Response
+     * @param deskName
+     * @param formData
+     * @returns DeskBundleUploadResponse Successful Response
      * @throws ApiError
      */
-    static recordBulkUpdate(podId, datastoreName, tableName, requestBody) {
+    static podDeskBundleUpload(podId, deskName, formData) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/bulk/update',
+            url: '/pods/{pod_id}/desks/{desk_name}/bundle',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
+                'desk_name': deskName,
             },
-            body: requestBody,
-            mediaType: 'application/json',
+            formData: formData,
+            mediaType: 'multipart/form-data',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Bulk Delete
-     * Delete multiple records by primary key values.
+     * Get Desk HTML
      * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param requestBody
-     * @returns DatastoreMessageResponse Successful Response
+     * @param deskName
+     * @returns any Successful Response
      * @throws ApiError
      */
-    static recordBulkDelete(podId, datastoreName, tableName, requestBody) {
+    static podDeskHtmlGet(podId, deskName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/bulk/delete',
+            method: 'GET',
+            url: '/pods/{pod_id}/desks/{desk_name}/html',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
+                'desk_name': deskName,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Query Records
-     * Query one table with structured filters and sorting. Use this instead of dynamic query parameters when you need filtering. Example filters: `[{"field": "status", "op": "eq", "value": "OPEN"}]`.
+     * Download Desk Source Archive
      * @param podId
-     * @param datastoreName
-     * @param tableName
-     * @param requestBody
-     * @returns RecordListResponse Successful Response
+     * @param deskName
+     * @returns any Successful Response
      * @throws ApiError
      */
-    static recordQuery(podId, datastoreName, tableName, requestBody) {
+    static podDeskSourceArchiveGet(podId, deskName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/query',
+            method: 'GET',
+            url: '/pods/{pod_id}/desks/{desk_name}/source/archive',
             path: {
                 'pod_id': podId,
-                'datastore_name': datastoreName,
-                'table_name': tableName,
+                'desk_name': deskName,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
 }
-exports.RecordsService = RecordsService;
+exports.DesksService = DesksService;
 
 },
 "./namespaces/files.js": function (module, exports, require) {
@@ -2321,104 +2405,138 @@ class FunctionsService {
 exports.FunctionsService = FunctionsService;
 
 },
-"./namespaces/agents.js": function (module, exports, require) {
+"./namespaces/icons.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentsNamespace = void 0;
-const AgentsService_js_1 = require("./openapi_client/services/AgentsService.js");
-class AgentsNamespace {
-    constructor(client, podId) {
+exports.IconsNamespace = void 0;
+const IconsService_js_1 = require("./openapi_client/services/IconsService.js");
+class IconsNamespace {
+    constructor(client) {
         this.client = client;
-        this.podId = podId;
-    }
-    list(options = {}) {
-        return this.client.request(() => AgentsService_js_1.AgentsService.agentList(this.podId(), options.limit ?? 100, options.pageToken));
-    }
-    create(payload) {
-        return this.client.request(() => AgentsService_js_1.AgentsService.agentCreate(this.podId(), payload));
-    }
-    get(agentName) {
-        return this.client.request(() => AgentsService_js_1.AgentsService.agentGet(this.podId(), agentName));
     }
-    update(agentName, payload) {
-        return this.client.request(() => AgentsService_js_1.AgentsService.agentUpdate(this.podId(), agentName, payload));
+    upload(file) {
+        return this.client.request(() => IconsService_js_1.IconsService.iconUpload({ file }));
     }
-    delete(agentName) {
-        return this.client.request(() => AgentsService_js_1.AgentsService.agentDelete(this.podId(), agentName));
+    getPublic(iconPath) {
+        return this.client.request(() => IconsService_js_1.IconsService.iconPublicGet(iconPath));
     }
 }
-exports.AgentsNamespace = AgentsNamespace;
+exports.IconsNamespace = IconsNamespace;
 
 },
-"./openapi_client/services/AgentsService.js": function (module, exports, require) {
+"./openapi_client/services/IconsService.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentsService = void 0;
+exports.IconsService = void 0;
 const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
 const request_js_1 = require("./openapi_client/core/request.js");
-class AgentsService {
+class IconsService {
     /**
-     * Create Agent
-     * Create a new agent in a pod
-     * @param podId
-     * @param requestBody
-     * @returns AgentResponse Successful Response
+     * Upload Icon
+     * Upload an image asset and receive a public icon URL.
+     * @param formData
+     * @returns IconUploadResponse Successful Response
      * @throws ApiError
      */
-    static agentCreate(podId, requestBody) {
+    static iconUpload(formData) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/agents',
-            path: {
-                'pod_id': podId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
+            url: '/icons/upload',
+            formData: formData,
+            mediaType: 'multipart/form-data',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * List Agents
-     * List all agents in a pod
-     * @param podId
-     * @param limit
-     * @param pageToken
-     * @returns AgentListResponse Successful Response
+     * Get Public Icon
+     * Fetch a previously uploaded public icon asset.
+     * @param iconPath
+     * @returns any Successful Response
      * @throws ApiError
      */
-    static agentList(podId, limit = 100, pageToken) {
+    static iconPublicGet(iconPath) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/agents',
+            url: '/public/icons/{icon_path}',
             path: {
-                'pod_id': podId,
-            },
-            query: {
-                'limit': limit,
-                'page_token': pageToken,
+                'icon_path': iconPath,
             },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
+}
+exports.IconsService = IconsService;
+
+},
+"./namespaces/integrations.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationsNamespace = void 0;
+const ApplicationsService_js_1 = require("./openapi_client/services/ApplicationsService.js");
+const IntegrationsService_js_1 = require("./openapi_client/services/IntegrationsService.js");
+class IntegrationsNamespace {
+    constructor(client) {
+        this.client = client;
+        this.operations = {
+            list: (applicationId) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationOperationList(applicationId)),
+            get: (applicationId, operationName) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationOperationDetail(applicationId, operationName)),
+            execute: (applicationId, operationName, payload, accountId) => {
+                const body = { payload, account_id: accountId };
+                return this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationOperationExecute(applicationId, operationName, body));
+            },
+            descriptor: (applicationId) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationDescriptor(applicationId)),
+        };
+        this.triggers = {
+            list: (options = {}) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationTriggerList(options.applicationId, options.search, options.limit ?? 100, options.pageToken)),
+            get: (triggerId) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationTriggerGet(triggerId)),
+        };
+        this.accounts = {
+            list: (options = {}) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountList(options.applicationId, options.limit ?? 100, options.pageToken)),
+            get: (accountId) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountGet(accountId)),
+            credentials: (accountId) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountCredentialsGet(accountId)),
+            delete: (accountId) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountDelete(accountId)),
+        };
+    }
+    list(options = {}) {
+        return this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationList(options.limit ?? 100, options.pageToken));
+    }
+    get(applicationId) {
+        return this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationGet(applicationId));
+    }
+    createConnectRequest(applicationId) {
+        const payload = { application_id: applicationId };
+        return this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationConnectRequestCreate(payload));
+    }
+}
+exports.IntegrationsNamespace = IntegrationsNamespace;
+
+},
+"./openapi_client/services/ApplicationsService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationsService = void 0;
+const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
+const request_js_1 = require("./openapi_client/core/request.js");
+class ApplicationsService {
     /**
-     * Get Agent
-     * Get an agent by name
-     * @param podId
-     * @param agentName
-     * @returns AgentResponse Successful Response
+     * List Applications
+     * Get all active applications available for integration
+     * @param limit
+     * @param pageToken
+     * @returns ApplicationListResponseSchema Successful Response
      * @throws ApiError
      */
-    static agentGet(podId, agentName) {
+    static applicationList(limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/agents/{agent_name}',
-            path: {
-                'pod_id': podId,
-                'agent_name': agentName,
+            url: '/integrations/applications',
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
             },
             errors: {
                 422: `Validation Error`,
@@ -2426,136 +2544,104 @@ class AgentsService {
         });
     }
     /**
-     * Update Agent
-     * Update an agent
-     * @param podId
-     * @param agentName
-     * @param requestBody
-     * @returns AgentResponse Successful Response
+     * List Triggers
+     * Get all triggers. Optionally filter by application_id and search in description
+     * @param applicationId
+     * @param search
+     * @param limit
+     * @param pageToken
+     * @returns AppTriggerListResponseSchema Successful Response
      * @throws ApiError
      */
-    static agentUpdate(podId, agentName, requestBody) {
+    static applicationTriggerList(applicationId, search, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'PATCH',
-            url: '/pods/{pod_id}/agents/{agent_name}',
-            path: {
-                'pod_id': podId,
-                'agent_name': agentName,
+            method: 'GET',
+            url: '/integrations/applications/triggers',
+            query: {
+                'application_id': applicationId,
+                'search': search,
+                'limit': limit,
+                'page_token': pageToken,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Delete Agent
-     * Delete an agent
-     * @param podId
-     * @param agentName
-     * @returns AgentMessageResponse Successful Response
+     * Get Trigger
+     * Get a specific trigger by ID
+     * @param triggerId
+     * @returns AppTriggerResponseSchema Successful Response
      * @throws ApiError
      */
-    static agentDelete(podId, agentName) {
+    static applicationTriggerGet(triggerId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'DELETE',
-            url: '/pods/{pod_id}/agents/{agent_name}',
+            method: 'GET',
+            url: '/integrations/applications/triggers/{trigger_id}',
             path: {
-                'pod_id': podId,
-                'agent_name': agentName,
+                'trigger_id': triggerId,
             },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
-}
-exports.AgentsService = AgentsService;
-
-},
-"./namespaces/tasks.js": function (module, exports, require) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TasksNamespace = void 0;
-const TasksService_js_1 = require("./openapi_client/services/TasksService.js");
-class TasksNamespace {
-    constructor(client, podId) {
-        this.client = client;
-        this.podId = podId;
-        this.messages = {
-            list: (taskId, options = {}) => this.client.request(() => TasksService_js_1.TasksService.taskMessageList(this.podId(), taskId, options.limit ?? 100, options.pageToken)),
-            add: (taskId, content) => {
-                const payload = { content };
-                return this.client.request(() => TasksService_js_1.TasksService.taskMessageAdd(this.podId(), taskId, payload));
+    /**
+     * Get Application
+     * Get a specific application by ID along with its operation catalog
+     * @param applicationId
+     * @returns ApplicationDetailResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static applicationGet(applicationId) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'GET',
+            url: '/integrations/applications/{application_id}',
+            path: {
+                'application_id': applicationId,
             },
-        };
-    }
-    list(options = {}) {
-        return this.client.request(() => TasksService_js_1.TasksService.taskList(this.podId(), options.agentName, options.limit ?? 100, options.pageToken));
-    }
-    create(options) {
-        const payload = { agent_name: options.agentName, input_data: options.input };
-        return this.client.request(() => TasksService_js_1.TasksService.taskCreate(this.podId(), payload));
-    }
-    get(taskId) {
-        return this.client.request(() => TasksService_js_1.TasksService.taskGet(this.podId(), taskId));
-    }
-    stop(taskId) {
-        return this.client.request(() => TasksService_js_1.TasksService.taskStop(this.podId(), taskId));
+            errors: {
+                422: `Validation Error`,
+            },
+        });
     }
-}
-exports.TasksNamespace = TasksNamespace;
-
-},
-"./openapi_client/services/TasksService.js": function (module, exports, require) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TasksService = void 0;
-const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
-const request_js_1 = require("./openapi_client/core/request.js");
-class TasksService {
     /**
-     * Create Task
-     * Create and start a new task
-     * @param podId
-     * @param requestBody
-     * @returns TaskResponse Successful Response
+     * Get Application Descriptor
+     * @param applicationId
+     * @returns AppDescriptorResponse Successful Response
      * @throws ApiError
      */
-    static taskCreate(podId, requestBody) {
+    static applicationDescriptor(applicationId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/tasks',
+            method: 'GET',
+            url: '/integrations/applications/{application_id}/operations/descriptor',
             path: {
-                'pod_id': podId,
+                'application_id': applicationId,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * List Tasks
-     * List all tasks in a pod
-     * @param podId
-     * @param agentName
+     * List Application Operations
+     * @param applicationId
+     * @param search
      * @param limit
      * @param pageToken
-     * @returns TaskListResponse Successful Response
+     * @returns OperationListResponse Successful Response
      * @throws ApiError
      */
-    static taskList(podId, agentName, limit = 100, pageToken) {
+    static applicationOperationList(applicationId, search, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/tasks',
+            url: '/integrations/applications/{application_id}/operations',
             path: {
-                'pod_id': podId,
+                'application_id': applicationId,
             },
             query: {
-                'agent_name': agentName,
+                'search': search,
                 'limit': limit,
                 'page_token': pageToken,
             },
@@ -2565,20 +2651,19 @@ class TasksService {
         });
     }
     /**
-     * Get Task
-     * Get a task by ID
-     * @param podId
-     * @param taskId
-     * @returns TaskResponse Successful Response
+     * Get Application Operation Details
+     * @param applicationId
+     * @param operationName
+     * @returns OperationDetail Successful Response
      * @throws ApiError
      */
-    static taskGet(podId, taskId) {
+    static applicationOperationDetail(applicationId, operationName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/tasks/{task_id}',
+            url: '/integrations/applications/{application_id}/operations/{operation_name}',
             path: {
-                'pod_id': podId,
-                'task_id': taskId,
+                'application_id': applicationId,
+                'operation_name': operationName,
             },
             errors: {
                 422: `Validation Error`,
@@ -2586,43 +2671,50 @@ class TasksService {
         });
     }
     /**
-     * Stop Task
-     * Stop a running task
-     * @param podId
-     * @param taskId
-     * @returns TaskResponse Successful Response
+     * Execute Application Operation
+     * @param applicationId
+     * @param operationName
+     * @param requestBody
+     * @returns OperationExecutionResponse Successful Response
      * @throws ApiError
      */
-    static taskStop(podId, taskId) {
+    static applicationOperationExecute(applicationId, operationName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'PATCH',
-            url: '/pods/{pod_id}/tasks/{task_id}/stop',
+            method: 'POST',
+            url: '/integrations/applications/{application_id}/operations/{operation_name}/execute',
             path: {
-                'pod_id': podId,
-                'task_id': taskId,
+                'application_id': applicationId,
+                'operation_name': operationName,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
+}
+exports.ApplicationsService = ApplicationsService;
+
+},
+"./openapi_client/services/IntegrationsService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationsService = void 0;
+const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
+const request_js_1 = require("./openapi_client/core/request.js");
+class IntegrationsService {
     /**
-     * Add Message
-     * Add a message to a task
-     * @param podId
-     * @param taskId
+     * Initiate Connect Request
+     * Initiate an OAuth connection request for an application
      * @param requestBody
-     * @returns TaskResponse Successful Response
+     * @returns ConnectRequestResponseSchema Successful Response
      * @throws ApiError
      */
-    static taskMessageAdd(podId, taskId, requestBody) {
+    static integrationConnectRequestCreate(requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/tasks/{task_id}/messages',
-            path: {
-                'pod_id': podId,
-                'task_id': taskId,
-            },
+            url: '/integrations/connect-requests',
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -2631,26 +2723,18 @@ class TasksService {
         });
     }
     /**
-     * List Messages
-     * List messages for a task
-     * @param podId
-     * @param taskId
-     * @param limit
-     * @param pageToken
-     * @returns TaskMessageListResponse Successful Response
+     * OAuth Callback
+     * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
+     * @param error
+     * @returns AccountResponseSchema Successful Response
      * @throws ApiError
      */
-    static taskMessageList(podId, taskId, limit = 100, pageToken) {
+    static integrationOauthCallback(error) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/tasks/{task_id}/messages',
-            path: {
-                'pod_id': podId,
-                'task_id': taskId,
-            },
+            url: '/integrations/connect-requests/oauth/callback',
             query: {
-                'limit': limit,
-                'page_token': pageToken,
+                'error': error,
             },
             errors: {
                 422: `Validation Error`,
@@ -2658,126 +2742,60 @@ class TasksService {
         });
     }
     /**
-     * Stream Task Updates
-     * Stream task updates via Server-Sent Events
-     * @param podId
-     * @param taskId
-     * @returns any Successful Response
+     * List Accounts
+     * Get all connected accounts for the current user. Optionally filter by application_id or application_name
+     * @param applicationId
+     * @param limit
+     * @param pageToken
+     * @returns AccountListResponseSchema Successful Response
      * @throws ApiError
      */
-    static taskStream(podId, taskId) {
+    static integrationAccountList(applicationId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/tasks/{task_id}/stream',
-            path: {
-                'pod_id': podId,
-                'task_id': taskId,
+            url: '/integrations/accounts',
+            query: {
+                'application_id': applicationId,
+                'limit': limit,
+                'page_token': pageToken,
             },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
-}
-exports.TasksService = TasksService;
-
-},
-"./namespaces/assistants.js": function (module, exports, require) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationsNamespace = exports.AssistantsNamespace = void 0;
-const AssistantsService_js_1 = require("./openapi_client/services/AssistantsService.js");
-const ConversationsService_js_1 = require("./openapi_client/services/ConversationsService.js");
-class AssistantsNamespace {
-    constructor(client, podId) {
-        this.client = client;
-        this.podId = podId;
-    }
-    list(options = {}) {
-        return this.client.request(() => AssistantsService_js_1.AssistantsService.assistantList(this.podId(), options.limit ?? 100, options.pageToken));
-    }
-    create(payload) {
-        return this.client.request(() => AssistantsService_js_1.AssistantsService.assistantCreate(this.podId(), payload));
-    }
-    get(assistantName) {
-        return this.client.request(() => AssistantsService_js_1.AssistantsService.assistantGet(this.podId(), assistantName));
-    }
-    update(assistantName, payload) {
-        return this.client.request(() => AssistantsService_js_1.AssistantsService.assistantUpdate(this.podId(), assistantName, payload));
-    }
-    delete(assistantName) {
-        return this.client.request(() => AssistantsService_js_1.AssistantsService.assistantDelete(this.podId(), assistantName));
-    }
-}
-exports.AssistantsNamespace = AssistantsNamespace;
-class ConversationsNamespace {
-    constructor(client, podId) {
-        this.client = client;
-        this.podId = podId;
-        this.messages = {
-            list: (conversationId, options = {}) => this.client.request(() => ConversationsService_js_1.ConversationsService.conversationMessageList(conversationId, this.podId(), options.pageToken, options.limit ?? 20)),
-            send: (conversationId, payload) => this.client.request(() => ConversationsService_js_1.ConversationsService.conversationMessageCreate(conversationId, payload, this.podId())),
-        };
-    }
-    list(options = {}) {
-        return this.client.request(() => ConversationsService_js_1.ConversationsService.conversationList(undefined, this.podId(), undefined, options.pageToken, options.limit ?? 20));
-    }
-    create(payload) {
-        return this.client.request(() => ConversationsService_js_1.ConversationsService.conversationCreate({ ...payload, pod_id: this.podId() }));
-    }
-    get(conversationId) {
-        return this.client.request(() => ConversationsService_js_1.ConversationsService.conversationGet(conversationId, this.podId()));
-    }
-}
-exports.ConversationsNamespace = ConversationsNamespace;
-
-},
-"./openapi_client/services/AssistantsService.js": function (module, exports, require) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssistantsService = void 0;
-const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
-const request_js_1 = require("./openapi_client/core/request.js");
-class AssistantsService {
     /**
-     * Create Assistant
-     * @param podId
-     * @param requestBody
-     * @returns AssistantResponse Successful Response
+     * Get Account
+     * Get a specific account by ID
+     * @param accountId
+     * @returns AccountResponseSchema Successful Response
      * @throws ApiError
      */
-    static assistantCreate(podId, requestBody) {
+    static integrationAccountGet(accountId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/assistants',
+            method: 'GET',
+            url: '/integrations/accounts/{account_id}',
             path: {
-                'pod_id': podId,
+                'account_id': accountId,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * List Assistants
-     * @param podId
-     * @param limit
-     * @param pageToken
-     * @returns AssistantListResponse Successful Response
+     * Delete Account
+     * Delete a connected account and revoke the connection
+     * @param accountId
+     * @returns MessageResponseSchema Successful Response
      * @throws ApiError
      */
-    static assistantList(podId, limit = 100, pageToken) {
+    static integrationAccountDelete(accountId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/pods/{pod_id}/assistants',
+            method: 'DELETE',
+            url: '/integrations/accounts/{account_id}',
             path: {
-                'pod_id': podId,
-            },
-            query: {
-                'limit': limit,
-                'page_token': pageToken,
+                'account_id': accountId,
             },
             errors: {
                 422: `Validation Error`,
@@ -2785,41 +2803,103 @@ class AssistantsService {
         });
     }
     /**
-     * Get Assistant
-     * @param podId
-     * @param assistantName
-     * @returns AssistantResponse Successful Response
+     * Get Credentials
+     * Get the credentials for a specific account
+     * @param accountId
+     * @returns AccountCredentialsResponseSchema Successful Response
      * @throws ApiError
      */
-    static assistantGet(podId, assistantName) {
+    static integrationAccountCredentialsGet(accountId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/assistants/{assistant_name}',
+            url: '/integrations/accounts/{account_id}/credentials',
             path: {
-                'pod_id': podId,
-                'assistant_name': assistantName,
+                'account_id': accountId,
             },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
+}
+exports.IntegrationsService = IntegrationsService;
+
+},
+"./namespaces/organizations.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationsNamespace = void 0;
+const OrganizationsService_js_1 = require("./openapi_client/services/OrganizationsService.js");
+class OrganizationsNamespace {
+    constructor(client, http) {
+        this.client = client;
+        this.http = http;
+        this.members = {
+            list: (orgId, options = {}) => this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgMemberList(orgId, options.limit ?? 100, options.pageToken ?? options.cursor)),
+            updateRole: (orgId, memberId, role) => this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgMemberUpdateRole(orgId, memberId, { role })),
+            remove: (orgId, memberId) => this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgMemberRemove(orgId, memberId)),
+        };
+        this.invitations = {
+            listMine: async (options = {}) => {
+                if (options.status) {
+                    return this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgInvitationListMine(options.status, options.limit ?? 100, options.pageToken ?? options.cursor));
+                }
+                return this.http.request("GET", "/organizations/invitations", {
+                    params: {
+                        limit: options.limit ?? 100,
+                        page_token: options.pageToken ?? options.cursor,
+                    },
+                });
+            },
+            list: async (orgId, options = {}) => {
+                if (options.status) {
+                    return this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgInvitationList(orgId, options.status, options.limit ?? 100, options.pageToken ?? options.cursor));
+                }
+                return this.http.request("GET", `/organizations/${encodeURIComponent(orgId)}/invitations`, {
+                    params: {
+                        limit: options.limit ?? 100,
+                        page_token: options.pageToken ?? options.cursor,
+                    },
+                });
+            },
+            get: (invitationId) => this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgInvitationGet(invitationId)),
+            invite: (orgId, payload) => this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgInvitationInvite(orgId, payload)),
+            accept: (invitationId) => this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgInvitationAccept(invitationId)),
+            revoke: (invitationId) => this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgInvitationRevoke(invitationId)),
+        };
+    }
+    list(options = {}) {
+        return this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgList(options.limit ?? 100, options.pageToken ?? options.cursor));
+    }
+    get(orgId) {
+        return this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgGet(orgId));
+    }
+    create(payload) {
+        return this.client.request(() => OrganizationsService_js_1.OrganizationsService.orgCreate(payload));
+    }
+}
+exports.OrganizationsNamespace = OrganizationsNamespace;
+
+},
+"./openapi_client/services/OrganizationsService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationsService = void 0;
+const OrganizationInvitationStatus_js_1 = require("./openapi_client/models/OrganizationInvitationStatus.js");
+const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
+const request_js_1 = require("./openapi_client/core/request.js");
+class OrganizationsService {
     /**
-     * Update Assistant
-     * @param podId
-     * @param assistantName
+     * Create Organization
+     * Create a new organization
      * @param requestBody
-     * @returns AssistantResponse Successful Response
+     * @returns OrganizationResponse Successful Response
      * @throws ApiError
      */
-    static assistantUpdate(podId, assistantName, requestBody) {
+    static orgCreate(requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'PATCH',
-            url: '/pods/{pod_id}/assistants/{assistant_name}',
-            path: {
-                'pod_id': podId,
-                'assistant_name': assistantName,
-            },
+            method: 'POST',
+            url: '/organizations',
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -2828,73 +2908,62 @@ class AssistantsService {
         });
     }
     /**
-     * Delete Assistant
-     * @param podId
-     * @param assistantName
-     * @returns void
+     * List My Organizations
+     * Get all organizations the current user belongs to
+     * @param limit
+     * @param pageToken
+     * @returns OrganizationListResponse Successful Response
      * @throws ApiError
      */
-    static assistantDelete(podId, assistantName) {
+    static orgList(limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'DELETE',
-            url: '/pods/{pod_id}/assistants/{assistant_name}',
-            path: {
-                'pod_id': podId,
-                'assistant_name': assistantName,
+            method: 'GET',
+            url: '/organizations',
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
             },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
-}
-exports.AssistantsService = AssistantsService;
-
-},
-"./openapi_client/services/ConversationsService.js": function (module, exports, require) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationsService = void 0;
-const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
-const request_js_1 = require("./openapi_client/core/request.js");
-class ConversationsService {
     /**
-     * Create Conversation
-     * @param requestBody
-     * @returns ConversationResponse Successful Response
+     * List My Invitations
+     * Get all pending invitations for the current user
+     * @param status
+     * @param limit
+     * @param pageToken
+     * @returns OrganizationInvitationListResponse Successful Response
      * @throws ApiError
      */
-    static conversationCreate(requestBody) {
+    static orgInvitationListMine(status = OrganizationInvitationStatus_js_1.OrganizationInvitationStatus.PENDING, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/conversations',
-            body: requestBody,
-            mediaType: 'application/json',
+            method: 'GET',
+            url: '/organizations/invitations',
+            query: {
+                'status': status,
+                'limit': limit,
+                'page_token': pageToken,
+            },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * List Conversations
-     * @param assistantId
-     * @param podId
-     * @param organizationId
-     * @param pageToken
-     * @param limit
-     * @returns ConversationListResponse Successful Response
+     * Get Organization
+     * Get organization details
+     * @param orgId
+     * @returns OrganizationResponse Successful Response
      * @throws ApiError
      */
-    static conversationList(assistantId, podId, organizationId, pageToken, limit = 20) {
+    static orgGet(orgId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/conversations',
-            query: {
-                'assistant_id': assistantId,
-                'pod_id': podId,
-                'organization_id': organizationId,
-                'page_token': pageToken,
-                'limit': limit,
+            url: '/organizations/{org_id}',
+            path: {
+                'org_id': orgId,
             },
             errors: {
                 422: `Validation Error`,
@@ -2902,21 +2971,24 @@ class ConversationsService {
         });
     }
     /**
-     * Get Conversation
-     * @param conversationId
-     * @param podId
-     * @returns ConversationResponse Successful Response
+     * List Organization Members
+     * Get all members of an organization
+     * @param orgId
+     * @param limit
+     * @param pageToken
+     * @returns OrganizationMemberListResponse Successful Response
      * @throws ApiError
      */
-    static conversationGet(conversationId, podId) {
+    static orgMemberList(orgId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/conversations/{conversation_id}',
+            url: '/organizations/{org_id}/members',
             path: {
-                'conversation_id': conversationId,
+                'org_id': orgId,
             },
             query: {
-                'pod_id': podId,
+                'limit': limit,
+                'page_token': pageToken,
             },
             errors: {
                 422: `Validation Error`,
@@ -2924,22 +2996,19 @@ class ConversationsService {
         });
     }
     /**
-     * Update Conversation
-     * @param conversationId
+     * Invite Member
+     * Invite a user to join the organization
+     * @param orgId
      * @param requestBody
-     * @param podId
-     * @returns ConversationResponse Successful Response
+     * @returns OrganizationInvitationResponse Successful Response
      * @throws ApiError
      */
-    static conversationUpdate(conversationId, requestBody, podId) {
+    static orgInvitationInvite(orgId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'PATCH',
-            url: '/conversations/{conversation_id}',
+            method: 'POST',
+            url: '/organizations/{org_id}/invitations',
             path: {
-                'conversation_id': conversationId,
-            },
-            query: {
-                'pod_id': podId,
+                'org_id': orgId,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -2949,26 +3018,26 @@ class ConversationsService {
         });
     }
     /**
-     * List Messages
-     * List messages in a conversation with token pagination. Use `page_token` to fetch older messages.
-     * @param conversationId
-     * @param podId
-     * @param pageToken
+     * List Organization Invitations
+     * Get all pending invitations for an organization
+     * @param orgId
+     * @param status
      * @param limit
-     * @returns ConversationMessageListResponse Successful Response
+     * @param pageToken
+     * @returns OrganizationInvitationListResponse Successful Response
      * @throws ApiError
      */
-    static conversationMessageList(conversationId, podId, pageToken, limit = 20) {
+    static orgInvitationList(orgId, status = OrganizationInvitationStatus_js_1.OrganizationInvitationStatus.PENDING, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/conversations/{conversation_id}/messages',
+            url: '/organizations/{org_id}/invitations',
             path: {
-                'conversation_id': conversationId,
+                'org_id': orgId,
             },
             query: {
-                'pod_id': podId,
-                'page_token': pageToken,
+                'status': status,
                 'limit': limit,
+                'page_token': pageToken,
             },
             errors: {
                 422: `Validation Error`,
@@ -2976,46 +3045,56 @@ class ConversationsService {
         });
     }
     /**
-     * Send Message (Stream)
-     * @param conversationId
-     * @param requestBody
-     * @param podId
-     * @returns any Server-Sent Events
+     * Accept Invitation
+     * Accept an organization invitation
+     * @param invitationId
+     * @returns OrganizationMessageResponse Successful Response
      * @throws ApiError
      */
-    static conversationMessageCreate(conversationId, requestBody, podId) {
+    static orgInvitationAccept(invitationId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/conversations/{conversation_id}/messages',
+            url: '/organizations/invitations/{invitation_id}/accept',
             path: {
-                'conversation_id': conversationId,
-            },
-            query: {
-                'pod_id': podId,
+                'invitation_id': invitationId,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Resume Conversation Stream
-     * @param conversationId
-     * @param podId
-     * @returns any Server-Sent Events for an already-running conversation.
+     * Get Organization Invitation
+     * Get an invitation by id
+     * @param invitationId
+     * @returns OrganizationInvitationResponse Successful Response
      * @throws ApiError
      */
-    static conversationStreamResume(conversationId, podId) {
+    static orgInvitationGet(invitationId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/conversations/{conversation_id}/stream',
+            url: '/organizations/invitations/{invitation_id}',
             path: {
-                'conversation_id': conversationId,
+                'invitation_id': invitationId,
             },
-            query: {
-                'pod_id': podId,
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Revoke Invitation
+     * Revoke an organization invitation
+     * @param invitationId
+     * @returns void
+     * @throws ApiError
+     */
+    static orgInvitationRevoke(invitationId) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/organizations/invitations/{invitation_id}',
+            path: {
+                'invitation_id': invitationId,
             },
             errors: {
                 422: `Validation Error`,
@@ -3023,21 +3102,44 @@ class ConversationsService {
         });
     }
     /**
-     * Stop Conversation Run
-     * @param conversationId
-     * @param podId
-     * @returns any Successful Response
+     * Update Member Role
+     * Update a member's role in the organization
+     * @param orgId
+     * @param memberId
+     * @param requestBody
+     * @returns OrganizationMemberResponse Successful Response
      * @throws ApiError
      */
-    static conversationRunStop(conversationId, podId) {
+    static orgMemberUpdateRole(orgId, memberId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'PATCH',
-            url: '/conversations/{conversation_id}/stop',
+            url: '/organizations/{org_id}/members/{member_id}/role',
             path: {
-                'conversation_id': conversationId,
+                'org_id': orgId,
+                'member_id': memberId,
             },
-            query: {
-                'pod_id': podId,
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Remove Member
+     * Remove a member from the organization
+     * @param orgId
+     * @param memberId
+     * @returns void
+     * @throws ApiError
+     */
+    static orgMemberRemove(orgId, memberId) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/organizations/{org_id}/members/{member_id}',
+            path: {
+                'org_id': orgId,
+                'member_id': memberId,
             },
             errors: {
                 422: `Validation Error`,
@@ -3045,70 +3147,73 @@ class ConversationsService {
         });
     }
 }
-exports.ConversationsService = ConversationsService;
+exports.OrganizationsService = OrganizationsService;
 
 },
-"./namespaces/workflows.js": function (module, exports, require) {
+"./openapi_client/models/OrganizationInvitationStatus.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowsNamespace = void 0;
-const WorkflowsService_js_1 = require("./openapi_client/services/WorkflowsService.js");
-class WorkflowsNamespace {
-    constructor(client, podId) {
+exports.OrganizationInvitationStatus = void 0;
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Statuses for organization invitations.
+ */
+var OrganizationInvitationStatus;
+(function (OrganizationInvitationStatus) {
+    OrganizationInvitationStatus["PENDING"] = "PENDING";
+    OrganizationInvitationStatus["ACCEPTED"] = "ACCEPTED";
+    OrganizationInvitationStatus["EXPIRED"] = "EXPIRED";
+    OrganizationInvitationStatus["REVOKED"] = "REVOKED";
+})(OrganizationInvitationStatus || (exports.OrganizationInvitationStatus = OrganizationInvitationStatus = {}));
+
+},
+"./namespaces/pod-members.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodMembersNamespace = void 0;
+const PodMembersService_js_1 = require("./openapi_client/services/PodMembersService.js");
+class PodMembersNamespace {
+    constructor(client) {
         this.client = client;
-        this.podId = podId;
-        this.graph = {
-            update: (workflowName, graph) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowGraphUpdate(this.podId(), workflowName, graph)),
-        };
-        this.installs = {
-            create: (workflowName, payload = {}) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowInstallCreate(this.podId(), workflowName, payload)),
-            delete: (workflowName, installId) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowInstallDelete(this.podId(), workflowName, installId)),
-        };
-        this.runs = {
-            start: (workflowName, inputs = {}) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowStart(this.podId(), workflowName, inputs)),
-            list: (workflowName, options = {}) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowRunList(this.podId(), workflowName, options.limit ?? 100, options.pageToken)),
-            get: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowRunGet(podId, runId)),
-            resume: (runId, inputs = {}, podId = this.podId()) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowRunResume(podId, runId, inputs)),
-        };
-    }
-    list(options = {}) {
-        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowList(this.podId(), options.limit ?? 100, options.pageToken));
     }
-    create(payload) {
-        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowCreate(this.podId(), payload));
+    list(podId, options = {}) {
+        return this.client.request(() => PodMembersService_js_1.PodMembersService.podMemberList(podId, options.limit ?? 100, options.pageToken ?? options.cursor));
     }
-    get(workflowName) {
-        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowGet(this.podId(), workflowName));
+    add(podId, payload) {
+        return this.client.request(() => PodMembersService_js_1.PodMembersService.podMemberAdd(podId, payload));
     }
-    update(workflowName, payload) {
-        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowUpdate(this.podId(), workflowName, payload));
+    updateRole(podId, memberId, role) {
+        return this.client.request(() => PodMembersService_js_1.PodMembersService.podMemberUpdateRole(podId, memberId, { role }));
     }
-    delete(workflowName) {
-        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowDelete(this.podId(), workflowName));
+    remove(podId, memberId) {
+        return this.client.request(() => PodMembersService_js_1.PodMembersService.podMemberRemove(podId, memberId));
     }
 }
-exports.WorkflowsNamespace = WorkflowsNamespace;
+exports.PodMembersNamespace = PodMembersNamespace;
 
 },
-"./openapi_client/services/WorkflowsService.js": function (module, exports, require) {
+"./openapi_client/services/PodMembersService.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowsService = void 0;
+exports.PodMembersService = void 0;
 const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
 const request_js_1 = require("./openapi_client/core/request.js");
-class WorkflowsService {
+class PodMembersService {
     /**
-     * Create Workflow
-     * Create a workflow definition. Use this before uploading graph nodes/edges with `workflow.graph.update`.
+     * Add Pod Member
+     * Add a member to a pod
      * @param podId
      * @param requestBody
-     * @returns FlowEntity Successful Response
+     * @returns PodMemberResponse Successful Response
      * @throws ApiError
      */
-    static workflowCreate(podId, requestBody) {
+    static podMemberAdd(podId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/workflows',
+            url: '/pods/{pod_id}/members',
             path: {
                 'pod_id': podId,
             },
@@ -3120,18 +3225,18 @@ class WorkflowsService {
         });
     }
     /**
-     * List Workflows
-     * List all workflows in a pod.
+     * List Pod Members
+     * List all members of a pod
      * @param podId
      * @param limit
      * @param pageToken
-     * @returns WorkflowListResponse Successful Response
+     * @returns PodMemberListResponse Successful Response
      * @throws ApiError
      */
-    static workflowList(podId, limit = 100, pageToken) {
+    static podMemberList(podId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/workflows',
+            url: '/pods/{pod_id}/members',
             path: {
                 'pod_id': podId,
             },
@@ -3145,42 +3250,21 @@ class WorkflowsService {
         });
     }
     /**
-     * Get Workflow
-     * Get a single workflow definition including graph and start configuration.
-     * @param podId
-     * @param workflowName
-     * @returns FlowEntity Successful Response
-     * @throws ApiError
-     */
-    static workflowGet(podId, workflowName) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/pods/{pod_id}/workflows/{workflow_name}',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Update Workflow Metadata
-     * Update workflow-level metadata such as description/install requirements. Workflow names are immutable after creation. Use `workflow.graph.update` for nodes and edges.
+     * Update Member Role
+     * Update a pod member's role
      * @param podId
-     * @param workflowName
+     * @param memberId
      * @param requestBody
-     * @returns FlowEntity Successful Response
+     * @returns PodMemberResponse Successful Response
      * @throws ApiError
      */
-    static workflowUpdate(podId, workflowName, requestBody) {
+    static podMemberUpdateRole(podId, memberId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'PATCH',
-            url: '/pods/{pod_id}/workflows/{workflow_name}',
+            url: '/pods/{pod_id}/members/{member_id}/role',
             path: {
                 'pod_id': podId,
-                'workflow_name': workflowName,
+                'member_id': memberId,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -3190,114 +3274,94 @@ class WorkflowsService {
         });
     }
     /**
-     * Delete Workflow
-     * Delete a workflow definition.
+     * Remove Pod Member
+     * Remove a member from a pod
      * @param podId
-     * @param workflowName
+     * @param memberId
      * @returns void
      * @throws ApiError
      */
-    static workflowDelete(podId, workflowName) {
+    static podMemberRemove(podId, memberId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'DELETE',
-            url: '/pods/{pod_id}/workflows/{workflow_name}',
+            url: '/pods/{pod_id}/members/{member_id}',
             path: {
                 'pod_id': podId,
-                'workflow_name': workflowName,
+                'member_id': memberId,
             },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
-    /**
-     * Update Workflow Graph
-     * Replace the workflow graph. Agent/function node `input_mapping` entries must use explicit typed bindings. Use `{type: "expression", value: "start.payload.issue.key"}` for context lookups and `{type: "literal", value: "abc"}` for fixed JSON values.
-     * @param podId
-     * @param workflowName
-     * @param requestBody
-     * @returns FlowEntity Successful Response
-     * @throws ApiError
-     */
-    static workflowGraphUpdate(podId, workflowName, requestBody) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'PUT',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/graph',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                422: `Validation Error`,
-            },
-        });
+}
+exports.PodMembersService = PodMembersService;
+
+},
+"./namespaces/pods.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodsNamespace = void 0;
+const PodsService_js_1 = require("./openapi_client/services/PodsService.js");
+class PodsNamespace {
+    constructor(client, http) {
+        this.client = client;
+        this.http = http;
     }
-    /**
-     * Install Workflow
-     * Install a workflow for runtime execution. Provide `account_id` when the workflow needs an integration account binding.
-     * @param podId
-     * @param workflowName
-     * @param requestBody
-     * @returns FlowInstallEntity Successful Response
-     * @throws ApiError
-     */
-    static workflowInstallCreate(podId, workflowName, requestBody) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/install',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                422: `Validation Error`,
+    list(options = {}) {
+        if (options.organizationId) {
+            return this.listByOrganization(options.organizationId, {
+                limit: options.limit,
+                pageToken: options.pageToken ?? options.cursor,
+            });
+        }
+        return this.http.request("GET", "/pods", {
+            params: {
+                limit: options.limit ?? 100,
+                page_token: options.pageToken ?? options.cursor,
             },
         });
     }
-    /**
-     * Uninstall Workflow
-     * Remove a previously created workflow installation binding.
-     * @param podId
-     * @param workflowName
-     * @param installId
-     * @returns void
-     * @throws ApiError
-     */
-    static workflowInstallDelete(podId, workflowName, installId) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'DELETE',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/installs/{install_id}',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-                'install_id': installId,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
+    listByOrganization(organizationId, options = {}) {
+        return this.client.request(() => PodsService_js_1.PodsService.podList(organizationId, options.limit ?? 100, options.pageToken ?? options.cursor));
+    }
+    get(podId) {
+        return this.client.request(() => PodsService_js_1.PodsService.podGet(podId));
+    }
+    create(payload) {
+        return this.client.request(() => PodsService_js_1.PodsService.podCreate(payload));
+    }
+    update(podId, payload) {
+        return this.client.request(() => PodsService_js_1.PodsService.podUpdate(podId, payload));
+    }
+    delete(podId) {
+        return this.client.request(() => PodsService_js_1.PodsService.podDelete(podId));
+    }
+    config(podId) {
+        return this.client.request(() => PodsService_js_1.PodsService.podConfigGet(podId));
     }
+}
+exports.PodsNamespace = PodsNamespace;
+
+},
+"./openapi_client/services/PodsService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodsService = void 0;
+const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
+const request_js_1 = require("./openapi_client/core/request.js");
+class PodsService {
     /**
-     * Start Workflow
-     * Start a new workflow run. For event/scheduled/datastore starts, the request body is treated as initial trigger payload and merged into execution context.
-     * @param podId
-     * @param workflowName
+     * Create Pod
+     * Create a new pod
      * @param requestBody
-     * @returns FlowRunEntity Successful Response
+     * @returns PodResponse Successful Response
      * @throws ApiError
      */
-    static workflowStart(podId, workflowName, requestBody) {
+    static podCreate(requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/start',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-            },
+            url: '/pods',
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -3306,20 +3370,18 @@ class WorkflowsService {
         });
     }
     /**
-     * Visualize Workflow
-     * Render an HTML visualization for debugging workflow graph structure.
+     * Get Pod
+     * Get pod details
      * @param podId
-     * @param workflowName
-     * @returns string Successful Response
+     * @returns PodResponse Successful Response
      * @throws ApiError
      */
-    static workflowVisualize(podId, workflowName) {
+    static podGet(podId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/visualize',
+            url: '/pods/{pod_id}',
             path: {
                 'pod_id': podId,
-                'workflow_name': workflowName,
             },
             errors: {
                 422: `Validation Error`,
@@ -3327,21 +3389,19 @@ class WorkflowsService {
         });
     }
     /**
-     * Resume Workflow Run
-     * Resume a run in WAITING or EXECUTING state. The payload is written back into the current waiting node output and execution continues.
+     * Update Pod
+     * Update pod details
      * @param podId
-     * @param runId
      * @param requestBody
-     * @returns FlowRunEntity Successful Response
+     * @returns PodResponse Successful Response
      * @throws ApiError
      */
-    static workflowRunResume(podId, runId, requestBody) {
+    static podUpdate(podId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/workflow-runs/{run_id}/resume',
+            method: 'PUT',
+            url: '/pods/{pod_id}',
             path: {
                 'pod_id': podId,
-                'run_id': runId,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -3351,20 +3411,18 @@ class WorkflowsService {
         });
     }
     /**
-     * Get Workflow Run
-     * Get current state, context, and step history of a workflow run.
+     * Delete Pod
+     * Delete a pod
      * @param podId
-     * @param runId
-     * @returns FlowRunEntity Successful Response
+     * @returns void
      * @throws ApiError
      */
-    static workflowRunGet(podId, runId) {
+    static podDelete(podId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/pods/{pod_id}/workflow-runs/{run_id}',
+            method: 'DELETE',
+            url: '/pods/{pod_id}',
             path: {
                 'pod_id': podId,
-                'run_id': runId,
             },
             errors: {
                 422: `Validation Error`,
@@ -3372,22 +3430,20 @@ class WorkflowsService {
         });
     }
     /**
-     * List Workflow Runs
-     * List recent runs for a given workflow.
-     * @param podId
-     * @param workflowName
+     * List PodS by Organization
+     * List all pods in an organization
+     * @param organizationId
      * @param limit
      * @param pageToken
-     * @returns WorkflowRunListResponse Successful Response
+     * @returns PodListResponse Successful Response
      * @throws ApiError
      */
-    static workflowRunList(podId, workflowName, limit = 100, pageToken) {
+    static podList(organizationId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/workflow-runs/{workflow_name}/runs',
+            url: '/pods/organization/{organization_id}',
             path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
+                'organization_id': organizationId,
             },
             query: {
                 'limit': limit,
@@ -3399,20 +3455,18 @@ class WorkflowsService {
         });
     }
     /**
-     * Visualize Workflow Run
-     * Render an HTML view of a run overlaid on its workflow graph.
+     * Get Pod Config
+     * Get pod configuration requirements (apps, flows) and user status
      * @param podId
-     * @param runId
-     * @returns string Successful Response
+     * @returns PodConfigResponse Successful Response
      * @throws ApiError
      */
-    static workflowRunVisualize(podId, runId) {
+    static podConfigGet(podId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/workflow-runs/{run_id}/visualize',
+            url: '/pods/{pod_id}/config',
             path: {
                 'pod_id': podId,
-                'run_id': runId,
             },
             errors: {
                 422: `Validation Error`,
@@ -3420,66 +3474,56 @@ class WorkflowsService {
         });
     }
 }
-exports.WorkflowsService = WorkflowsService;
+exports.PodsService = PodsService;
 
 },
-"./namespaces/desks.js": function (module, exports, require) {
+"./namespaces/pod-surfaces.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesksNamespace = void 0;
-const DesksService_js_1 = require("./openapi_client/services/DesksService.js");
-class DesksNamespace {
-    constructor(client, http, podId) {
+exports.PodSurfacesNamespace = void 0;
+const AssistantSurfacesService_js_1 = require("./openapi_client/services/AssistantSurfacesService.js");
+class PodSurfacesNamespace {
+    constructor(client) {
         this.client = client;
-        this.http = http;
-        this.podId = podId;
-        this.html = {
-            get: (name) => this.client.request(() => DesksService_js_1.DesksService.podDeskHtmlGet(this.podId(), name)),
-        };
-        this.bundle = {
-            upload: (name, payload) => this.client.request(() => DesksService_js_1.DesksService.podDeskBundleUpload(this.podId(), name, payload)),
-        };
-        this.source = {
-            download: (name) => this.http.requestBytes("GET", `/pods/${this.podId()}/desks/${name}/source/archive`),
-        };
     }
-    list(options = {}) {
-        return this.client.request(() => DesksService_js_1.DesksService.podDeskList(this.podId(), options.limit ?? 100, options.pageToken));
+    list(podId, options = {}) {
+        return this.client.request(() => AssistantSurfacesService_js_1.AssistantSurfacesService.assistantSurfaceList(podId, options.limit ?? 100, options.pageToken ?? options.cursor));
     }
-    create(payload) {
-        return this.client.request(() => DesksService_js_1.DesksService.podDeskCreate(this.podId(), payload));
+    create(podId, payload) {
+        return this.client.request(() => AssistantSurfacesService_js_1.AssistantSurfacesService.assistantSurfaceCreate(podId, payload));
     }
-    get(name) {
-        return this.client.request(() => DesksService_js_1.DesksService.podDeskGet(this.podId(), name));
+    get(podId, surfaceId) {
+        return this.client.request(() => AssistantSurfacesService_js_1.AssistantSurfacesService.assistantSurfaceGet(podId, surfaceId));
     }
-    update(name, payload) {
-        return this.client.request(() => DesksService_js_1.DesksService.podDeskUpdate(this.podId(), name, payload));
+    updateConfig(podId, surfaceId, payload) {
+        return this.client.request(() => AssistantSurfacesService_js_1.AssistantSurfacesService.assistantSurfaceUpdateConfig(podId, surfaceId, payload));
     }
-    delete(name) {
-        return this.client.request(() => DesksService_js_1.DesksService.podDeskDelete(this.podId(), name));
+    toggle(podId, surfaceId, isActive) {
+        return this.client.request(() => AssistantSurfacesService_js_1.AssistantSurfacesService.assistantSurfaceToggle(podId, surfaceId, { is_active: isActive }));
     }
 }
-exports.DesksNamespace = DesksNamespace;
+exports.PodSurfacesNamespace = PodSurfacesNamespace;
 
 },
-"./openapi_client/services/DesksService.js": function (module, exports, require) {
+"./openapi_client/services/AssistantSurfacesService.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesksService = void 0;
+exports.AssistantSurfacesService = void 0;
 const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
 const request_js_1 = require("./openapi_client/core/request.js");
-class DesksService {
+class AssistantSurfacesService {
     /**
-     * Create Desk
+     * Create Surface
+     * Create a new surface for an assistant.
      * @param podId
      * @param requestBody
-     * @returns DeskResponse Successful Response
+     * @returns any Successful Response
      * @throws ApiError
      */
-    static podDeskCreate(podId, requestBody) {
+    static assistantSurfaceCreate(podId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/desks',
+            url: '/pods/{pod_id}/surfaces',
             path: {
                 'pod_id': podId,
             },
@@ -3491,17 +3535,18 @@ class DesksService {
         });
     }
     /**
-     * List Desks
+     * List Surfaces
+     * List configured surfaces in a pod.
      * @param podId
      * @param limit
      * @param pageToken
-     * @returns DeskListResponse Successful Response
+     * @returns AssistantSurfaceListResponse Successful Response
      * @throws ApiError
      */
-    static podDeskList(podId, limit = 100, pageToken) {
+    static assistantSurfaceList(podId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/desks',
+            url: '/pods/{pod_id}/surfaces',
             path: {
                 'pod_id': podId,
             },
@@ -3515,19 +3560,20 @@ class DesksService {
         });
     }
     /**
-     * Get Desk
+     * Get Surface
+     * Get a specific surface configuration.
      * @param podId
-     * @param deskName
-     * @returns DeskResponse Successful Response
+     * @param surfaceId
+     * @returns any Successful Response
      * @throws ApiError
      */
-    static podDeskGet(podId, deskName) {
+    static assistantSurfaceGet(podId, surfaceId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/desks/{desk_name}',
+            url: '/pods/{pod_id}/surfaces/{surface_id}',
             path: {
                 'pod_id': podId,
-                'desk_name': deskName,
+                'surface_id': surfaceId,
             },
             errors: {
                 422: `Validation Error`,
@@ -3535,20 +3581,21 @@ class DesksService {
         });
     }
     /**
-     * Update Desk
+     * Update Surface
+     * Update a surface configuration.
      * @param podId
-     * @param deskName
+     * @param surfaceId
      * @param requestBody
-     * @returns DeskResponse Successful Response
+     * @returns any Successful Response
      * @throws ApiError
      */
-    static podDeskUpdate(podId, deskName, requestBody) {
+    static assistantSurfaceUpdateConfig(podId, surfaceId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'PATCH',
-            url: '/pods/{pod_id}/desks/{desk_name}',
+            url: '/pods/{pod_id}/surfaces/{surface_id}/config',
             path: {
                 'pod_id': podId,
-                'desk_name': deskName,
+                'surface_id': surfaceId,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -3558,82 +3605,621 @@ class DesksService {
         });
     }
     /**
-     * Delete Desk
+     * Toggle Surface
+     * Toggle a surface active state.
      * @param podId
-     * @param deskName
-     * @returns DeskMessageResponse Successful Response
+     * @param surfaceId
+     * @param requestBody
+     * @returns any Successful Response
      * @throws ApiError
      */
-    static podDeskDelete(podId, deskName) {
+    static assistantSurfaceToggle(podId, surfaceId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'DELETE',
-            url: '/pods/{pod_id}/desks/{desk_name}',
+            method: 'PATCH',
+            url: '/pods/{pod_id}/surfaces/{surface_id}/toggle',
             path: {
                 'pod_id': podId,
-                'desk_name': deskName,
+                'surface_id': surfaceId,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
-    /**
-     * Upload Desk Bundle
-     * @param podId
-     * @param deskName
-     * @param formData
-     * @returns DeskBundleUploadResponse Successful Response
-     * @throws ApiError
-     */
-    static podDeskBundleUpload(podId, deskName, formData) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/desks/{desk_name}/bundle',
-            path: {
-                'pod_id': podId,
-                'desk_name': deskName,
+}
+exports.AssistantSurfacesService = AssistantSurfacesService;
+
+},
+"./namespaces/records.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordsNamespace = void 0;
+const RecordsService_js_1 = require("./openapi_client/services/RecordsService.js");
+function getRecordsPath(podId, datastore, table) {
+    return `/pods/${encodeURIComponent(podId)}/datastores/${encodeURIComponent(datastore)}/tables/${encodeURIComponent(table)}/records`;
+}
+class RecordsNamespace {
+    constructor(client, http, podId) {
+        this.client = client;
+        this.http = http;
+        this.podId = podId;
+        this.bulk = {
+            create: (datastore, table, records) => {
+                const payload = { records };
+                return this.client.request(() => RecordsService_js_1.RecordsService.recordBulkCreate(this.podId(), datastore, table, payload));
             },
-            formData: formData,
-            mediaType: 'multipart/form-data',
-            errors: {
-                422: `Validation Error`,
+            update: (datastore, table, records) => {
+                const payload = { records };
+                return this.client.request(() => RecordsService_js_1.RecordsService.recordBulkUpdate(this.podId(), datastore, table, payload));
             },
-        });
+            delete: (datastore, table, recordIds) => {
+                const payload = { record_ids: recordIds };
+                return this.client.request(() => RecordsService_js_1.RecordsService.recordBulkDelete(this.podId(), datastore, table, payload));
+            },
+        };
     }
-    /**
-     * Get Desk HTML
-     * @param podId
-     * @param deskName
-     * @returns any Successful Response
-     * @throws ApiError
-     */
-    static podDeskHtmlGet(podId, deskName) {
-        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+    list(datastore, table, options = {}) {
+        const { filters, sort, limit, pageToken, offset, sortBy, order, params } = options;
+        if (filters || sort) {
+            const payload = {
+                filters,
+                sort,
+                limit,
+                page_token: pageToken,
+            };
+            return this.client.request(() => RecordsService_js_1.RecordsService.recordQuery(this.podId(), datastore, table, payload));
+        }
+        const hasCustomParams = typeof offset === "number" ||
+            typeof sortBy === "string" ||
+            typeof order === "string" ||
+            !!params;
+        if (hasCustomParams) {
+            return this.http.request("GET", getRecordsPath(this.podId(), datastore, table), {
+                params: {
+                    limit: limit ?? 20,
+                    page_token: pageToken,
+                    offset,
+                    sort_by: sortBy,
+                    order,
+                    ...(params ?? {}),
+                },
+            });
+        }
+        return this.client.request(() => RecordsService_js_1.RecordsService.recordList(this.podId(), datastore, table, limit ?? 20, pageToken));
+    }
+    listWithParams(datastore, table, params) {
+        return this.http.request("GET", getRecordsPath(this.podId(), datastore, table), {
+            params,
+        });
+    }
+    create(datastore, table, data) {
+        return this.client.request(() => RecordsService_js_1.RecordsService.recordCreate(this.podId(), datastore, table, { data }));
+    }
+    get(datastore, table, recordId) {
+        return this.client.request(() => RecordsService_js_1.RecordsService.recordGet(this.podId(), datastore, table, recordId));
+    }
+    update(datastore, table, recordId, data) {
+        return this.client.request(() => RecordsService_js_1.RecordsService.recordUpdate(this.podId(), datastore, table, recordId, { data }));
+    }
+    delete(datastore, table, recordId) {
+        return this.client.request(() => RecordsService_js_1.RecordsService.recordDelete(this.podId(), datastore, table, recordId));
+    }
+    query(datastore, table, payload) {
+        return this.client.request(() => RecordsService_js_1.RecordsService.recordQuery(this.podId(), datastore, table, payload));
+    }
+}
+exports.RecordsNamespace = RecordsNamespace;
+
+},
+"./openapi_client/services/RecordsService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordsService = void 0;
+const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
+const request_js_1 = require("./openapi_client/core/request.js");
+class RecordsService {
+    /**
+     * Create Record
+     * Insert a record into a table. Reserved tables (`reserved_*`) are system-managed and cannot be mutated through record write endpoints.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param requestBody
+     * @returns RecordResponse Successful Response
+     * @throws ApiError
+     */
+    static recordCreate(podId, datastoreName, tableName, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * List Records
+     * List table records with token pagination only. Use `record.query` when you need structured filters or explicit sort clauses.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param limit Max number of rows to return.
+     * @param pageToken Opaque token from a previous response page.
+     * @returns RecordListResponse Successful Response
+     * @throws ApiError
+     */
+    static recordList(podId, datastoreName, tableName, limit = 20, pageToken) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/desks/{desk_name}/html',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Get Record
+     * Fetch one record by primary key value. The `record_id` path segment is the table's primary key value as stored in the table, not necessarily a UUID.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param recordId
+     * @returns RecordResponse Successful Response
+     * @throws ApiError
+     */
+    static recordGet(podId, datastoreName, tableName, recordId) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/{record_id}',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+                'record_id': recordId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Update Record
+     * Patch a record by primary key.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param recordId
+     * @param requestBody
+     * @returns RecordResponse Successful Response
+     * @throws ApiError
+     */
+    static recordUpdate(podId, datastoreName, tableName, recordId, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'PATCH',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/{record_id}',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+                'record_id': recordId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Delete Record
+     * Delete a record by primary key.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param recordId
+     * @returns DatastoreMessageResponse Successful Response
+     * @throws ApiError
+     */
+    static recordDelete(podId, datastoreName, tableName, recordId) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/{record_id}',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+                'record_id': recordId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Bulk Create
+     * Insert multiple records in one request.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param requestBody
+     * @returns DatastoreMessageResponse Successful Response
+     * @throws ApiError
+     */
+    static recordBulkCreate(podId, datastoreName, tableName, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/bulk/create',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Bulk Update
+     * Update multiple records in one request (each item needs primary key).
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param requestBody
+     * @returns DatastoreMessageResponse Successful Response
+     * @throws ApiError
+     */
+    static recordBulkUpdate(podId, datastoreName, tableName, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/bulk/update',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Bulk Delete
+     * Delete multiple records by primary key values.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param requestBody
+     * @returns DatastoreMessageResponse Successful Response
+     * @throws ApiError
+     */
+    static recordBulkDelete(podId, datastoreName, tableName, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/bulk/delete',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Query Records
+     * Query one table with structured filters and sorting. Use this instead of dynamic query parameters when you need filtering. Example filters: `[{"field": "status", "op": "eq", "value": "OPEN"}]`.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param requestBody
+     * @returns RecordListResponse Successful Response
+     * @throws ApiError
+     */
+    static recordQuery(podId, datastoreName, tableName, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/records/query',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+}
+exports.RecordsService = RecordsService;
+
+},
+"./namespaces/resources.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcesNamespace = void 0;
+class ResourcesNamespace {
+    constructor(http) {
+        this.http = http;
+    }
+    list(resourceType, resourceId, options = {}) {
+        return this.http.request("GET", `/files/${resourceType}/${resourceId}/list`, {
+            params: {
+                path: options.path,
+            },
+        });
+    }
+    upload(resourceType, resourceId, file, options = {}) {
+        const formData = new FormData();
+        const fieldName = options.fieldName ?? "file";
+        const name = options.name ?? (file instanceof File ? file.name : "upload.bin");
+        formData.append(fieldName, file, name);
+        return this.http.request("POST", `/files/${resourceType}/${resourceId}/upload`, {
+            params: {
+                path: options.path,
+            },
+            body: formData,
+            isFormData: true,
+        });
+    }
+    delete(resourceType, resourceId, filePath) {
+        return this.http.request("DELETE", `/files/${resourceType}/${resourceId}/delete/${filePath}`);
+    }
+    download(resourceType, resourceId, filePath) {
+        return this.http.requestBytes("GET", `/files/${resourceType}/${resourceId}/download/${filePath}`);
+    }
+}
+exports.ResourcesNamespace = ResourcesNamespace;
+
+},
+"./namespaces/tables.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TablesNamespace = void 0;
+const TablesService_js_1 = require("./openapi_client/services/TablesService.js");
+function normalizeCreateTablePayload(payload) {
+    if ("table_name" in payload) {
+        const { table_name, name, ...rest } = payload;
+        return {
+            ...rest,
+            name: name ?? table_name,
+        };
+    }
+    return payload;
+}
+class TablesNamespace {
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+        this.columns = {
+            add: (datastore, tableName, request) => {
+                const payload = "column" in request ? request : { column: request };
+                return this.client.request(() => TablesService_js_1.TablesService.tableColumnAdd(this.podId(), datastore, tableName, payload));
+            },
+            remove: (datastore, tableName, columnName) => this.client.request(() => TablesService_js_1.TablesService.tableColumnRemove(this.podId(), datastore, tableName, columnName)),
+        };
+    }
+    list(datastore, options = {}) {
+        return this.client.request(() => TablesService_js_1.TablesService.tableList(this.podId(), datastore, options.limit ?? 100, options.pageToken));
+    }
+    create(datastore, payload) {
+        return this.client.request(() => TablesService_js_1.TablesService.tableCreate(this.podId(), datastore, normalizeCreateTablePayload(payload)));
+    }
+    get(datastore, tableName) {
+        return this.client.request(() => TablesService_js_1.TablesService.tableGet(this.podId(), datastore, tableName));
+    }
+    update(datastore, tableName, payload) {
+        return this.client.request(() => TablesService_js_1.TablesService.tableUpdate(this.podId(), datastore, tableName, payload));
+    }
+    delete(datastore, tableName) {
+        return this.client.request(() => TablesService_js_1.TablesService.tableDelete(this.podId(), datastore, tableName));
+    }
+}
+exports.TablesNamespace = TablesNamespace;
+
+},
+"./openapi_client/services/TablesService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TablesService = void 0;
+const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
+const request_js_1 = require("./openapi_client/core/request.js");
+class TablesService {
+    /**
+     * Create Table
+     * Create a table in a datastore. Define primary key, column schema, and optional RLS behavior.
+     * @param podId
+     * @param datastoreName
+     * @param requestBody
+     * @returns TableResponse Successful Response
+     * @throws ApiError
+     */
+    static tableCreate(podId, datastoreName, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * List Tables
+     * List tables in a datastore.
+     * @param podId
+     * @param datastoreName
+     * @param limit Max number of tables to return.
+     * @param pageToken Cursor from a previous response for pagination.
+     * @returns TableListResponse Successful Response
+     * @throws ApiError
+     */
+    static tableList(podId, datastoreName, limit = 100, pageToken) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Get Table
+     * Get table schema metadata by table name.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @returns TableResponse Successful Response
+     * @throws ApiError
+     */
+    static tableGet(podId, datastoreName, tableName) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Delete Table
+     * Delete a table and all records in it.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @returns DatastoreMessageResponse Successful Response
+     * @throws ApiError
+     */
+    static tableDelete(podId, datastoreName, tableName) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Update Table
+     * Update table metadata/configuration payload.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param requestBody
+     * @returns TableResponse Successful Response
+     * @throws ApiError
+     */
+    static tableUpdate(podId, datastoreName, tableName, requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'PATCH',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}',
             path: {
                 'pod_id': podId,
-                'desk_name': deskName,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Download Desk Source Archive
+     * Add Column
+     * Add a new column to a table. Column names must be unique and compatible with existing table schema rules.
      * @param podId
-     * @param deskName
-     * @returns any Successful Response
+     * @param datastoreName
+     * @param tableName
+     * @param requestBody
+     * @returns TableResponse Successful Response
      * @throws ApiError
      */
-    static podDeskSourceArchiveGet(podId, deskName) {
+    static tableColumnAdd(podId, datastoreName, tableName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/pods/{pod_id}/desks/{desk_name}/source/archive',
+            method: 'POST',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/columns',
             path: {
                 'pod_id': podId,
-                'desk_name': deskName,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Remove Column
+     * Remove a non-primary, non-system column from a table. System columns and the primary key cannot be removed.
+     * @param podId
+     * @param datastoreName
+     * @param tableName
+     * @param columnName
+     * @returns DatastoreMessageResponse Successful Response
+     * @throws ApiError
+     */
+    static tableColumnRemove(podId, datastoreName, tableName, columnName) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/pods/{pod_id}/datastores/{datastore_name}/tables/{table_name}/columns/{column_name}',
+            path: {
+                'pod_id': podId,
+                'datastore_name': datastoreName,
+                'table_name': tableName,
+                'column_name': columnName,
             },
             errors: {
                 422: `Validation Error`,
@@ -3641,118 +4227,261 @@ class DesksService {
         });
     }
 }
-exports.DesksService = DesksService;
+exports.TablesService = TablesService;
 
 },
-"./namespaces/integrations.js": function (module, exports, require) {
+"./namespaces/tasks.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegrationsNamespace = void 0;
-const ApplicationsService_js_1 = require("./openapi_client/services/ApplicationsService.js");
-const IntegrationsService_js_1 = require("./openapi_client/services/IntegrationsService.js");
-class IntegrationsNamespace {
-    constructor(client) {
-        this.client = client;
-        this.operations = {
-            list: (applicationId) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationOperationList(applicationId)),
-            get: (applicationId, operationName) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationOperationDetail(applicationId, operationName)),
-            execute: (applicationId, operationName, payload, accountId) => {
-                const body = { payload, account_id: accountId };
-                return this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationOperationExecute(applicationId, operationName, body));
+exports.TasksNamespace = void 0;
+class TasksNamespace {
+    constructor(http, podId) {
+        this.http = http;
+        this.podId = podId;
+        this.messages = {
+            list: (taskId, options = {}) => this.http.request("GET", `/pods/${this.podId()}/tasks/${taskId}/messages`, {
+                params: {
+                    limit: options.limit ?? 100,
+                    page_token: options.pageToken ?? options.cursor,
+                    cursor: options.cursor,
+                },
+            }),
+            add: (taskId, content) => {
+                const payload = { content };
+                return this.http.request("POST", `/pods/${this.podId()}/tasks/${taskId}/messages`, {
+                    body: payload,
+                });
             },
-            descriptor: (applicationId) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationDescriptor(applicationId)),
-        };
-        this.triggers = {
-            list: (options = {}) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationTriggerList(options.applicationId, options.search, options.limit ?? 100, options.pageToken)),
-            get: (triggerId) => this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationTriggerGet(triggerId)),
-        };
-        this.accounts = {
-            list: (options = {}) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountList(options.applicationId, options.limit ?? 100, options.pageToken)),
-            get: (accountId) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountGet(accountId)),
-            credentials: (accountId) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountCredentialsGet(accountId)),
-            delete: (accountId) => this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationAccountDelete(accountId)),
         };
     }
     list(options = {}) {
-        return this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationList(options.limit ?? 100, options.pageToken));
+        return this.http.request("GET", `/pods/${this.podId()}/tasks`, {
+            params: {
+                agent_name: options.agentName,
+                agent_id: options.agentId,
+                limit: options.limit ?? 100,
+                page_token: options.pageToken ?? options.cursor,
+                cursor: options.cursor,
+            },
+        });
     }
-    get(applicationId) {
-        return this.client.request(() => ApplicationsService_js_1.ApplicationsService.applicationGet(applicationId));
+    create(options) {
+        if (!options.agentId && !options.agentName) {
+            throw new Error("Either agentId or agentName is required.");
+        }
+        return this.http.request("POST", `/pods/${this.podId()}/tasks`, {
+            body: {
+                agent_id: options.agentId,
+                agent_name: options.agentName ?? options.agentId,
+                input_data: options.input,
+                runtime_account_ids: options.runtimeAccountIds,
+            },
+        });
     }
-    createConnectRequest(applicationId) {
-        const payload = { application_id: applicationId };
-        return this.client.request(() => IntegrationsService_js_1.IntegrationsService.integrationConnectRequestCreate(payload));
+    get(taskId) {
+        return this.http.request("GET", `/pods/${this.podId()}/tasks/${taskId}`);
+    }
+    stop(taskId) {
+        return this.http.request("PATCH", `/pods/${this.podId()}/tasks/${taskId}/stop`);
+    }
+    stream(taskId, options = {}) {
+        return this.http.stream(`/pods/${this.podId()}/tasks/${taskId}/stream`, {
+            signal: options.signal,
+            headers: {
+                Accept: "text/event-stream",
+            },
+        });
     }
 }
-exports.IntegrationsNamespace = IntegrationsNamespace;
+exports.TasksNamespace = TasksNamespace;
 
 },
-"./openapi_client/services/ApplicationsService.js": function (module, exports, require) {
+"./namespaces/users.js": function (module, exports, require) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApplicationsService = void 0;
+exports.UsersNamespace = void 0;
+const UsersService_js_1 = require("./openapi_client/services/UsersService.js");
+class UsersNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    current() {
+        return this.client.request(() => UsersService_js_1.UsersService.userCurrentGet());
+    }
+    getProfile() {
+        return this.client.request(() => UsersService_js_1.UsersService.userProfileGet());
+    }
+    upsertProfile(payload) {
+        return this.client.request(() => UsersService_js_1.UsersService.userProfileUpsert(payload));
+    }
+}
+exports.UsersNamespace = UsersNamespace;
+
+},
+"./openapi_client/services/UsersService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersService = void 0;
 const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
 const request_js_1 = require("./openapi_client/core/request.js");
-class ApplicationsService {
+class UsersService {
     /**
-     * List Applications
-     * Get all active applications available for integration
-     * @param limit
-     * @param pageToken
-     * @returns ApplicationListResponseSchema Successful Response
+     * Get Current User
+     * Get the current authenticated user's information
+     * @returns UserResponse Successful Response
      * @throws ApiError
      */
-    static applicationList(limit = 100, pageToken) {
+    static userCurrentGet() {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/integrations/applications',
-            query: {
-                'limit': limit,
-                'page_token': pageToken,
-            },
+            url: '/users/me',
+        });
+    }
+    /**
+     * Get User Profile
+     * Get the current user's profile
+     * @returns UserResponse Successful Response
+     * @throws ApiError
+     */
+    static userProfileGet() {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'GET',
+            url: '/users/me/profile',
+        });
+    }
+    /**
+     * Create or Update Profile
+     * Create or update the current user's profile
+     * @param requestBody
+     * @returns UserResponse Successful Response
+     * @throws ApiError
+     */
+    static userProfileUpsert(requestBody) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'POST',
+            url: '/users/me/profile',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
+}
+exports.UsersService = UsersService;
+
+},
+"./namespaces/workflows.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowsNamespace = void 0;
+const http_js_1 = require("./http.js");
+const WorkflowsService_js_1 = require("./openapi_client/services/WorkflowsService.js");
+class WorkflowsNamespace {
+    constructor(client, http, podId) {
+        this.client = client;
+        this.http = http;
+        this.podId = podId;
+        this.graph = {
+            update: (workflowName, graph) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowGraphUpdate(this.podId(), workflowName, graph)),
+        };
+        this.installs = {
+            create: (workflowName, payload = {}) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowInstallCreate(this.podId(), workflowName, payload)),
+            delete: (workflowName, installId) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowInstallDelete(this.podId(), workflowName, installId)),
+        };
+        this.runs = {
+            start: (workflowName, inputs = {}) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowStart(this.podId(), workflowName, inputs)),
+            list: (workflowName, options = {}) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowRunList(this.podId(), workflowName, options.limit ?? 100, options.pageToken)),
+            get: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowRunGet(podId, runId)),
+            resume: (runId, inputs = {}, podId = this.podId()) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowRunResume(podId, runId, inputs)),
+            visualize: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowRunVisualize(podId, runId)),
+            cancel: (runId, podId = this.podId()) => this.postRunAction(runId, "cancel", podId),
+            retry: (runId, podId = this.podId()) => this.postRunAction(runId, "retry", podId),
+        };
+    }
+    list(options = {}) {
+        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowCreate(this.podId(), payload));
+    }
+    get(workflowName) {
+        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowGet(this.podId(), workflowName));
+    }
+    update(workflowName, payload) {
+        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowUpdate(this.podId(), workflowName, payload));
+    }
+    delete(workflowName) {
+        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowDelete(this.podId(), workflowName));
+    }
+    visualize(workflowName) {
+        return this.client.request(() => WorkflowsService_js_1.WorkflowsService.workflowVisualize(this.podId(), workflowName));
+    }
+    async postRunAction(runId, action, podId) {
+        const encodedPodId = encodeURIComponent(podId);
+        const encodedRunId = encodeURIComponent(runId);
+        try {
+            return await this.http.request("POST", `/pods/${encodedPodId}/workflow-runs/${encodedRunId}/${action}`, { body: {} });
+        }
+        catch (error) {
+            if (error instanceof http_js_1.ApiError && (error.statusCode === 404 || error.statusCode === 405)) {
+                return this.http.request("POST", `/pods/${encodedPodId}/flow-runs/${encodedRunId}/${action}`, { body: {} });
+            }
+            throw error;
+        }
+    }
+}
+exports.WorkflowsNamespace = WorkflowsNamespace;
+
+},
+"./openapi_client/services/WorkflowsService.js": function (module, exports, require) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowsService = void 0;
+const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
+const request_js_1 = require("./openapi_client/core/request.js");
+class WorkflowsService {
     /**
-     * List Triggers
-     * Get all triggers. Optionally filter by application_id and search in description
-     * @param applicationId
-     * @param search
-     * @param limit
-     * @param pageToken
-     * @returns AppTriggerListResponseSchema Successful Response
+     * Create Workflow
+     * Create a workflow definition. Use this before uploading graph nodes/edges with `workflow.graph.update`.
+     * @param podId
+     * @param requestBody
+     * @returns FlowEntity Successful Response
      * @throws ApiError
      */
-    static applicationTriggerList(applicationId, search, limit = 100, pageToken) {
+    static workflowCreate(podId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/integrations/applications/triggers',
-            query: {
-                'application_id': applicationId,
-                'search': search,
-                'limit': limit,
-                'page_token': pageToken,
+            method: 'POST',
+            url: '/pods/{pod_id}/workflows',
+            path: {
+                'pod_id': podId,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Get Trigger
-     * Get a specific trigger by ID
-     * @param triggerId
-     * @returns AppTriggerResponseSchema Successful Response
+     * List Workflows
+     * List all workflows in a pod.
+     * @param podId
+     * @param limit
+     * @param pageToken
+     * @returns WorkflowListResponse Successful Response
      * @throws ApiError
      */
-    static applicationTriggerGet(triggerId) {
+    static workflowList(podId, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/integrations/applications/triggers/{trigger_id}',
+            url: '/pods/{pod_id}/workflows',
             path: {
-                'trigger_id': triggerId,
+                'pod_id': podId,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
             },
             errors: {
                 422: `Validation Error`,
@@ -3760,18 +4489,20 @@ class ApplicationsService {
         });
     }
     /**
-     * Get Application
-     * Get a specific application by ID along with its operation catalog
-     * @param applicationId
-     * @returns ApplicationDetailResponseSchema Successful Response
+     * Get Workflow
+     * Get a single workflow definition including graph and start configuration.
+     * @param podId
+     * @param workflowName
+     * @returns FlowEntity Successful Response
      * @throws ApiError
      */
-    static applicationGet(applicationId) {
+    static workflowGet(podId, workflowName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/integrations/applications/{application_id}',
+            url: '/pods/{pod_id}/workflows/{workflow_name}',
             path: {
-                'application_id': applicationId,
+                'pod_id': podId,
+                'workflow_name': workflowName,
             },
             errors: {
                 422: `Validation Error`,
@@ -3779,43 +4510,44 @@ class ApplicationsService {
         });
     }
     /**
-     * Get Application Descriptor
-     * @param applicationId
-     * @returns AppDescriptorResponse Successful Response
+     * Update Workflow Metadata
+     * Update workflow-level metadata such as description/install requirements. Workflow names are immutable after creation. Use `workflow.graph.update` for nodes and edges.
+     * @param podId
+     * @param workflowName
+     * @param requestBody
+     * @returns FlowEntity Successful Response
      * @throws ApiError
      */
-    static applicationDescriptor(applicationId) {
+    static workflowUpdate(podId, workflowName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/integrations/applications/{application_id}/operations/descriptor',
+            method: 'PATCH',
+            url: '/pods/{pod_id}/workflows/{workflow_name}',
             path: {
-                'application_id': applicationId,
+                'pod_id': podId,
+                'workflow_name': workflowName,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * List Application Operations
-     * @param applicationId
-     * @param search
-     * @param limit
-     * @param pageToken
-     * @returns OperationListResponse Successful Response
+     * Delete Workflow
+     * Delete a workflow definition.
+     * @param podId
+     * @param workflowName
+     * @returns void
      * @throws ApiError
      */
-    static applicationOperationList(applicationId, search, limit = 100, pageToken) {
+    static workflowDelete(podId, workflowName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/integrations/applications/{application_id}/operations',
+            method: 'DELETE',
+            url: '/pods/{pod_id}/workflows/{workflow_name}',
             path: {
-                'application_id': applicationId,
-            },
-            query: {
-                'search': search,
-                'limit': limit,
-                'page_token': pageToken,
+                'pod_id': podId,
+                'workflow_name': workflowName,
             },
             errors: {
                 422: `Validation Error`,
@@ -3823,40 +4555,45 @@ class ApplicationsService {
         });
     }
     /**
-     * Get Application Operation Details
-     * @param applicationId
-     * @param operationName
-     * @returns OperationDetail Successful Response
+     * Update Workflow Graph
+     * Replace the workflow graph. Agent/function node `input_mapping` entries must use explicit typed bindings. Use `{type: "expression", value: "start.payload.issue.key"}` for context lookups and `{type: "literal", value: "abc"}` for fixed JSON values.
+     * @param podId
+     * @param workflowName
+     * @param requestBody
+     * @returns FlowEntity Successful Response
      * @throws ApiError
      */
-    static applicationOperationDetail(applicationId, operationName) {
+    static workflowGraphUpdate(podId, workflowName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/integrations/applications/{application_id}/operations/{operation_name}',
+            method: 'PUT',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/graph',
             path: {
-                'application_id': applicationId,
-                'operation_name': operationName,
+                'pod_id': podId,
+                'workflow_name': workflowName,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Execute Application Operation
-     * @param applicationId
-     * @param operationName
+     * Install Workflow
+     * Install a workflow for runtime execution. Provide `account_id` when the workflow needs an integration account binding.
+     * @param podId
+     * @param workflowName
      * @param requestBody
-     * @returns OperationExecutionResponse Successful Response
+     * @returns FlowInstallEntity Successful Response
      * @throws ApiError
      */
-    static applicationOperationExecute(applicationId, operationName, requestBody) {
+    static workflowInstallCreate(podId, workflowName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/integrations/applications/{application_id}/operations/{operation_name}/execute',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/install',
             path: {
-                'application_id': applicationId,
-                'operation_name': operationName,
+                'pod_id': podId,
+                'workflow_name': workflowName,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -3865,28 +4602,46 @@ class ApplicationsService {
             },
         });
     }
-}
-exports.ApplicationsService = ApplicationsService;
-
-},
-"./openapi_client/services/IntegrationsService.js": function (module, exports, require) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegrationsService = void 0;
-const OpenAPI_js_1 = require("./openapi_client/core/OpenAPI.js");
-const request_js_1 = require("./openapi_client/core/request.js");
-class IntegrationsService {
     /**
-     * Initiate Connect Request
-     * Initiate an OAuth connection request for an application
+     * Uninstall Workflow
+     * Remove a previously created workflow installation binding.
+     * @param podId
+     * @param workflowName
+     * @param installId
+     * @returns void
+     * @throws ApiError
+     */
+    static workflowInstallDelete(podId, workflowName, installId) {
+        return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/installs/{install_id}',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+                'install_id': installId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Start Workflow
+     * Start a new workflow run. For event/scheduled/datastore starts, the request body is treated as initial trigger payload and merged into execution context.
+     * @param podId
+     * @param workflowName
      * @param requestBody
-     * @returns ConnectRequestResponseSchema Successful Response
+     * @returns FlowRunEntity Successful Response
      * @throws ApiError
      */
-    static integrationConnectRequestCreate(requestBody) {
+    static workflowStart(podId, workflowName, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'POST',
-            url: '/integrations/connect-requests',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/start',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -3895,18 +4650,20 @@ class IntegrationsService {
         });
     }
     /**
-     * OAuth Callback
-     * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
-     * @param error
-     * @returns AccountResponseSchema Successful Response
+     * Visualize Workflow
+     * Render an HTML visualization for debugging workflow graph structure.
+     * @param podId
+     * @param workflowName
+     * @returns string Successful Response
      * @throws ApiError
      */
-    static integrationOauthCallback(error) {
+    static workflowVisualize(podId, workflowName) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/integrations/connect-requests/oauth/callback',
-            query: {
-                'error': error,
+            url: '/pods/{pod_id}/workflows/{workflow_name}/visualize',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
             },
             errors: {
                 422: `Validation Error`,
@@ -3914,41 +4671,44 @@ class IntegrationsService {
         });
     }
     /**
-     * List Accounts
-     * Get all connected accounts for the current user. Optionally filter by application_id or application_name
-     * @param applicationId
-     * @param limit
-     * @param pageToken
-     * @returns AccountListResponseSchema Successful Response
+     * Resume Workflow Run
+     * Resume a run in WAITING or EXECUTING state. The payload is written back into the current waiting node output and execution continues.
+     * @param podId
+     * @param runId
+     * @param requestBody
+     * @returns FlowRunEntity Successful Response
      * @throws ApiError
      */
-    static integrationAccountList(applicationId, limit = 100, pageToken) {
+    static workflowRunResume(podId, runId, requestBody) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'GET',
-            url: '/integrations/accounts',
-            query: {
-                'application_id': applicationId,
-                'limit': limit,
-                'page_token': pageToken,
+            method: 'POST',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}/resume',
+            path: {
+                'pod_id': podId,
+                'run_id': runId,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Get Account
-     * Get a specific account by ID
-     * @param accountId
-     * @returns AccountResponseSchema Successful Response
+     * Get Workflow Run
+     * Get current state, context, and step history of a workflow run.
+     * @param podId
+     * @param runId
+     * @returns FlowRunEntity Successful Response
      * @throws ApiError
      */
-    static integrationAccountGet(accountId) {
+    static workflowRunGet(podId, runId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/integrations/accounts/{account_id}',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}',
             path: {
-                'account_id': accountId,
+                'pod_id': podId,
+                'run_id': runId,
             },
             errors: {
                 422: `Validation Error`,
@@ -3956,18 +4716,26 @@ class IntegrationsService {
         });
     }
     /**
-     * Delete Account
-     * Delete a connected account and revoke the connection
-     * @param accountId
-     * @returns MessageResponseSchema Successful Response
+     * List Workflow Runs
+     * List recent runs for a given workflow.
+     * @param podId
+     * @param workflowName
+     * @param limit
+     * @param pageToken
+     * @returns WorkflowRunListResponse Successful Response
      * @throws ApiError
      */
-    static integrationAccountDelete(accountId) {
+    static workflowRunList(podId, workflowName, limit = 100, pageToken) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
-            method: 'DELETE',
-            url: '/integrations/accounts/{account_id}',
+            method: 'GET',
+            url: '/pods/{pod_id}/workflow-runs/{workflow_name}/runs',
             path: {
-                'account_id': accountId,
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
             },
             errors: {
                 422: `Validation Error`,
@@ -3975,18 +4743,20 @@ class IntegrationsService {
         });
     }
     /**
-     * Get Credentials
-     * Get the credentials for a specific account
-     * @param accountId
-     * @returns AccountCredentialsResponseSchema Successful Response
+     * Visualize Workflow Run
+     * Render an HTML view of a run overlaid on its workflow graph.
+     * @param podId
+     * @param runId
+     * @returns string Successful Response
      * @throws ApiError
      */
-    static integrationAccountCredentialsGet(accountId) {
+    static workflowRunVisualize(podId, runId) {
         return (0, request_js_1.request)(OpenAPI_js_1.OpenAPI, {
             method: 'GET',
-            url: '/integrations/accounts/{account_id}/credentials',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}/visualize',
             path: {
-                'account_id': accountId,
+                'pod_id': podId,
+                'run_id': runId,
             },
             errors: {
                 422: `Validation Error`,
@@ -3994,7 +4764,7 @@ class IntegrationsService {
         });
     }
 }
-exports.IntegrationsService = IntegrationsService;
+exports.WorkflowsService = WorkflowsService;
 
 }
   };