@ptkl/sdk 1.13.0 → 1.15.0

package/dist/index.0.10.js

@@ -100,6 +100,9 @@ var ProtokolSDK010 = (function (exports, axios) {
             this.env = null;
             this.token = null;
             this.host = null;
+            this.env = env;
+            this.token = token;
+            this.host = host;
         }
     }
 
@@ -117,6 +120,7 @@ var ProtokolSDK010 = (function (exports, axios) {
             if (opts && opts.stream === true) {
                 let onMetaCallback = () => { };
                 let onDataCallback = () => { };
+                let onCursorCallback = () => { };
                 let onErrorCallback;
                 let onEndCallback;
                 let isFirstLine = true;
@@ -129,6 +133,10 @@ var ProtokolSDK010 = (function (exports, axios) {
                         onDataCallback = callback;
                         return chainable;
                     },
+                    onCursor: (callback) => {
+                        onCursorCallback = callback;
+                        return chainable;
+                    },
                     onError: (callback) => {
                         onErrorCallback = callback;
                         return chainable;
@@ -147,6 +155,11 @@ var ProtokolSDK010 = (function (exports, axios) {
                                     if (result instanceof Promise)
                                         await result;
                                 }
+                                else if ('next_cursor' in doc && !('uuid' in doc)) {
+                                    const result = onCursorCallback(doc);
+                                    if (result instanceof Promise)
+                                        await result;
+                                }
                                 else {
                                     const result = onDataCallback(doc);
                                     if (result instanceof Promise)
@@ -217,6 +230,8 @@ var ProtokolSDK010 = (function (exports, axios) {
             };
             if (ctx.only && ctx.only.length > 0)
                 params.only = ctx.only;
+            if (ctx.cursor)
+                params.cursor = ctx.cursor;
             if (Object.keys(ctx.$adv || {}).length > 0)
                 params.$adv = [(_b = ctx.$adv) !== null && _b !== void 0 ? _b : {}];
             if (ctx.$aggregate && ctx.$aggregate.length > 0)
@@ -883,11 +898,32 @@ var ProtokolSDK010 = (function (exports, axios) {
         }
         // Permissions & Roles
         /**
-         * Get user permissions
+         * Get the current token's permissions.
+         *
+         * Returns the resolved permission set carried by the calling token. For a
+         * forge actor token this is the scoped intersection minted at launch time —
+         * see `getPrincipalPermissions()` for the underlying user's full set.
          */
         async getPermissions() {
             return await this.client.get("/v1/user/role/permissions");
         }
+        /**
+         * Get the FULL permissions of the user the current token is acting on behalf
+         * of (the "principal").
+         *
+         * When a forge app runs under an actor token, `getPermissions()` returns only
+         * the token's scoped permissions — the intersection of the app's declared
+         * runtime permissions and the user's permissions. This instead returns the
+         * complete permission set of the underlying user, so the app can check what
+         * that user is actually allowed to do, independent of what the app itself was
+         * granted. The token scope is unchanged: this exposes knowledge, not capability.
+         *
+         * For a normal user session (no actor token) it returns the caller's own
+         * permissions, identical to `getPermissions()`'s scope.
+         */
+        async getPrincipalPermissions() {
+            return await this.client.get("/v1/user/role/principal-permissions");
+        }
         /**
          * Get list of available permissions
          */
@@ -972,7 +1008,7 @@ var ProtokolSDK010 = (function (exports, axios) {
          * @returns Promise resolving to the created/updated component
          */
         async setup(data) {
-            return await this.client.post("/v3/system/component/setup", data);
+            return await this.client.post("/v4/system/component/setup", data);
         }
     }
 
@@ -1228,9 +1264,22 @@ var ProtokolSDK010 = (function (exports, axios) {
         }
     }
 
+    /**
+     * Sandbox client — spark (FaaS) functions/apps, long-running runtimes, and
+     * their K8s deployments. All routes go through the `sandbox/…` gateway
+     * prefix (`/luma/sandbox/v1/...`), matching the sandbox service's REST
+     * surface (`internal/controllers/{spark.go,spark.v1.go,runtime.v1.go}` and
+     * the deployment lifecycle in `internal/controllers/ecomm/deployment.go`).
+     */
     class Sandbox extends PlatformBaseClient {
+        // ---------------------------------------------------------------
+        // Spark (FaaS functions / apps)
+        // ---------------------------------------------------------------
         /**
-         * Call the sandbox service to execute a serverless function
+         * Call the sandbox service to execute a serverless function.
+         *
+         * Kept for backwards compatibility — equivalent to
+         * `execSpark(name, data)`.
          *
          * @param name
          * @param data
@@ -1242,6 +1291,143 @@ var ProtokolSDK010 = (function (exports, axios) {
         async spark(name, data) {
             return await this.client.post(`/luma/sandbox/v1/spark/exec/${name}`, data);
         }
+        /**
+         * Create a new spark (function or app).
+         *
+         * @example
+         * const spark = await platform.sandbox().createSpark({ name: "myFunction", runtime: "node20", memory: 256 })
+         */
+        async createSpark(payload) {
+            return await this.client.post(`/luma/sandbox/v1/spark`, payload);
+        }
+        /**
+         * Get a spark by uuid.
+         */
+        async getSpark(uuid) {
+            return await this.client.get(`/luma/sandbox/v1/spark/${uuid}`);
+        }
+        /**
+         * Update a spark's memory/settings/env vars.
+         */
+        async updateSpark(uuid, payload) {
+            return await this.client.patch(`/luma/sandbox/v1/spark/${uuid}`, payload);
+        }
+        /**
+         * Delete a spark.
+         */
+        async deleteSpark(uuid) {
+            return await this.client.delete(`/luma/sandbox/v1/spark/${uuid}`);
+        }
+        /**
+         * List all sparks for the current project.
+         */
+        async listSparks() {
+            return await this.client.get(`/luma/sandbox/v1/spark`);
+        }
+        /**
+         * Deploy a specific spark version to the dev environment.
+         */
+        async deploySpark(uuid, version) {
+            return await this.client.put(`/luma/sandbox/v1/spark/deploy/${uuid}/${version}`);
+        }
+        /**
+         * Cancel an in-progress spark deployment.
+         *
+         * @param uuid
+         * @param env - defaults to "dev" on the server if omitted
+         */
+        async cancelSpark(uuid, env) {
+            return await this.client.put(`/luma/sandbox/v1/spark/cancel/${uuid}`, undefined, { params: env ? { env } : undefined });
+        }
+        /**
+         * Release a deployed spark version to the live/public environment.
+         */
+        async releaseSpark(uuid, version) {
+            return await this.client.put(`/luma/sandbox/v1/spark/release/${uuid}/${version}`);
+        }
+        /**
+         * Execute a deployed spark by name. Mirrors `spark()` but accepts the
+         * full request shape (method/query/headers) — the exec route accepts
+         * GET/POST/PATCH/PUT/DELETE.
+         *
+         * @example
+         * const result = await platform.sandbox().execSpark("myFunction", { foo: "bar" })
+         * const result = await platform.sandbox().execSpark("myFunction", undefined, { method: "GET" })
+         */
+        async execSpark(name, data, options) {
+            var _a;
+            const method = ((_a = options === null || options === void 0 ? void 0 : options.method) !== null && _a !== void 0 ? _a : "POST").toLowerCase();
+            return await this.client.request({
+                url: `/luma/sandbox/v1/spark/exec/${name}`,
+                method,
+                data,
+                params: options === null || options === void 0 ? void 0 : options.query,
+                headers: options === null || options === void 0 ? void 0 : options.headers,
+            });
+        }
+        /**
+         * Fetch logs for a spark.
+         */
+        async sparkLogs(uuid, params) {
+            return await this.client.get(`/luma/sandbox/v1/spark/logs/${uuid}`, { params });
+        }
+        /**
+         * Get the current project's spark tier (plan/quota).
+         */
+        async sparkTier() {
+            return await this.client.get(`/luma/sandbox/v1/spark/project/tier`);
+        }
+        // ---------------------------------------------------------------
+        // Runtimes (long-running user API deployments)
+        // ---------------------------------------------------------------
+        /**
+         * List all runtimes for the current project.
+         */
+        async listRuntimes() {
+            return await this.client.get(`/luma/sandbox/v1/runtime`);
+        }
+        /**
+         * Create a new runtime.
+         */
+        async createRuntime(payload) {
+            return await this.client.post(`/luma/sandbox/v1/runtime`, payload);
+        }
+        /**
+         * Get a runtime by ref (name/uuid).
+         */
+        async getRuntime(ref) {
+            return await this.client.get(`/luma/sandbox/v1/runtime/${ref}`);
+        }
+        /**
+         * Update a runtime's image/resources/env vars/tags.
+         */
+        async updateRuntime(ref, payload) {
+            return await this.client.patch(`/luma/sandbox/v1/runtime/${ref}`, payload);
+        }
+        /**
+         * Delete a runtime.
+         */
+        async deleteRuntime(ref) {
+            return await this.client.delete(`/luma/sandbox/v1/runtime/${ref}`);
+        }
+        /**
+         * (Re)deploy a runtime.
+         */
+        async deployRuntime(ref) {
+            return await this.client.post(`/luma/sandbox/v1/runtime/${ref}/deploy`);
+        }
+        /**
+         * Restart a running runtime.
+         */
+        async restartRuntime(ref) {
+            return await this.client.post(`/luma/sandbox/v1/runtime/${ref}/restart`);
+        }
+        /**
+         * Fetch logs for a runtime.
+         */
+        async runtimeLogs(ref, params) {
+            return await this.client.get(`/luma/sandbox/v1/runtime/${ref}/logs`, { params });
+        }
     }
 
     class System extends PlatformBaseClient {
@@ -1269,6 +1455,17 @@ var ProtokolSDK010 = (function (exports, axios) {
         }
     }
 
+    function nodeControlQuery(options) {
+        const params = new URLSearchParams();
+        if ((options === null || options === void 0 ? void 0 : options.iterationIdx) !== undefined) {
+            params.set('iteration_idx', String(options.iterationIdx));
+        }
+        if ((options === null || options === void 0 ? void 0 : options.parentNodeId) !== undefined) {
+            params.set('parent_node_id', String(options.parentNodeId));
+        }
+        const qs = params.toString();
+        return qs ? `?${qs}` : '';
+    }
     class Workflow extends PlatformBaseClient {
         async create(data) {
             return await this.client.post(`/v1/project/workflow/workflow`, data);
@@ -1291,8 +1488,123 @@ var ProtokolSDK010 = (function (exports, axios) {
         async publish(event, data) {
             return await this.client.post(`/v1/project/workflow/workflow/event/${event}`, data);
         }
+        /**
+         * Install (create + publish) a workflow in one call.
+         * Rejects if a workflow with the same name + integrator already exists.
+         */
+        async install(data) {
+            return await this.client.post(`/v1/project/workflow/workflow/install`, data);
+        }
+        // --- Execution history ---
+        async getHistory(query) {
+            return await this.client.get(`/v1/project/workflow/workflows/history`, { params: query });
+        }
+        async getHistoryEntry(executionUuid) {
+            return await this.client.get(`/v1/project/workflow/workflows/history/${executionUuid}`);
+        }
+        async getStats(query) {
+            return await this.client.get(`/v1/project/workflow/workflows/stats`, { params: query });
+        }
+        // --- Running executions ---
+        async getRunning(query) {
+            return await this.client.get(`/v1/project/workflow/workflows/running`, { params: query });
+        }
+        async getRunningEntry(executionUuid) {
+            return await this.client.get(`/v1/project/workflow/workflows/running/${executionUuid}`);
+        }
+        // --- Workflow execution control ---
+        async pause(executionUuid) {
+            return await this.client.post(`/v1/project/workflow/workflows/${executionUuid}/pause`);
+        }
+        async resume(executionUuid) {
+            return await this.client.post(`/v1/project/workflow/workflows/${executionUuid}/resume`);
+        }
+        async kill(executionUuid) {
+            return await this.client.post(`/v1/project/workflow/workflows/${executionUuid}/kill`);
+        }
+        /**
+         * Restart a failed/killed workflow execution from history.
+         * `clearState: true` discards prior node state instead of a smart resume.
+         */
+        async restart(executionUuid, options) {
+            const qs = (options === null || options === void 0 ? void 0 : options.clearState) ? '?clear_state=true' : '';
+            return await this.client.post(`/v1/project/workflow/workflows/${executionUuid}/restart${qs}`);
+        }
+        // --- Node-level control ---
+        async pauseNode(executionUuid, nodeId, options) {
+            return await this.client.post(`/v1/project/workflow/workflows/${executionUuid}/nodes/${nodeId}/pause${nodeControlQuery(options)}`);
+        }
+        async resumeNode(executionUuid, nodeId, options) {
+            return await this.client.post(`/v1/project/workflow/workflows/${executionUuid}/nodes/${nodeId}/resume${nodeControlQuery(options)}`);
+        }
+        async killNode(executionUuid, nodeId, options) {
+            return await this.client.post(`/v1/project/workflow/workflows/${executionUuid}/nodes/${nodeId}/kill${nodeControlQuery(options)}`);
+        }
+        // --- Errors ---
+        async getErrors() {
+            return await this.client.get(`/v1/project/workflow/errors`);
+        }
+        async removeError(id) {
+            return await this.client.delete(`/v1/project/workflow/errors/${id}`);
+        }
+        async removeAllErrors() {
+            return await this.client.delete(`/v1/project/workflow/errors`);
+        }
     }
 
+    /**
+     * Resolve the current app's UUID from the ambient platform context.
+     * The platform injects it per-installation: FORGE_APP_UUID in __ENV_VARIABLES__
+     * for public views, and forge_app_uuid in sessionStorage for platform views.
+     * Returns null outside the browser (e.g. Node/CLI), where the caller must pass
+     * an explicit appUuid.
+     */
+    function resolveCurrentAppUuid() {
+        var _a;
+        if (!isBrowser)
+            return null;
+        // @ts-ignore
+        const fromEnv = (_a = window.__ENV_VARIABLES__) === null || _a === void 0 ? void 0 : _a.FORGE_APP_UUID;
+        if (fromEnv)
+            return fromEnv;
+        try {
+            return sessionStorage.getItem("forge_app_uuid");
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Resolve a service target into { ref, serviceName }.
+     *
+     * Two forms, cleanly split:
+     *  - a bare service name (no "prn:" prefix) → the CURRENT app's service (the ref
+     *    is the current app's uuid, resolved from the platform context); or
+     *  - a service PRN `prn:forge:{ref}:service/{serviceName}` → ANOTHER app's service
+     *    (canonical PRN grammar: kind + name in the path, url-encoded).
+     *
+     * A PRN's `ref` may be an app **name** OR a uuid. Names aren't unique within a
+     * project (a marketplace install and a custom app can share one), so the runtime
+     * resolves a name deterministically **marketplace → custom**. Pass the uuid when
+     * you need a *specific* app.
+     */
+    function parseServiceTarget(target) {
+        if (!target.startsWith("prn:")) {
+            // bare service name → the current app
+            return { ref: resolveCurrentAppUuid(), serviceName: target };
+        }
+        // PRN → another app. Path form: prn:forge:{ref}:service/{serviceName}
+        // (the PRN path segment is "service/{name}", with the name url-encoded).
+        const [, type, ref, ...rest] = target.split(":");
+        const path = rest.join(":"); // the PRN path, e.g. "service/{name}"
+        const [kind, ...nameParts] = path.split("/");
+        const serviceName = decodeURIComponent(nameParts.join("/"));
+        if (type !== "forge" || kind !== "service" || !ref || !serviceName) {
+            throw new Error(`runService: invalid service PRN "${target}" ` +
+                `(expected prn:forge:{ref}:service/{serviceName}, where ref is an app name or uuid)`);
+        }
+        return { ref, serviceName };
+    }
     class Forge extends PlatformBaseClient {
         // --- Management (appservice) ---
         async bundleUpload(buffer) {
@@ -1330,156 +1642,202 @@ var ProtokolSDK010 = (function (exports, axios) {
             return await this.client.patch(`/luma/appservice/v1/forge/${ref}/variables`, current);
         }
         // --- Service execution (forge-runtime) ---
-        async callService(appUuid, serviceName, options) {
-            var _a, _b, _c;
+        /**
+         * Run a Forge service: `runService(target, body?, { query?, headers? })`.
+         * Mirrors `axios.post(url, data, config)` — the 2nd arg is the request payload.
+         *
+         * `target` is either:
+         *  - a bare service name — runs that service on the CURRENT app; or
+         *  - a service PRN `prn:forge:{ref}:service/{name}` — runs it on ANOTHER app,
+         *    where `ref` is the app's **name** or uuid. A name is resolved by the
+         *    runtime deterministically (marketplace → custom); use the uuid to pin a
+         *    specific app. This is the addressing to use where there's no ambient
+         *    "current app" — e.g. a workflow, which has no per-install uuid to hardcode.
+         *
+         * `body` is sent as the POST body; `options.query` / `options.headers` are optional.
+         *
+         * The current app's uuid (bare-name form) is resolved automatically from the
+         * platform context (FORGE_APP_UUID for public views, forge_app_uuid in
+         * sessionStorage for platform views), so app code never needs its own uuid.
+         *
+         * Resolving the app does NOT grant access. Execution is still authorized against
+         * the caller's permissions — for a `platform`-access service the caller must hold
+         * `service::{name} forge::{appUuid}`; `public`-access services require none. An
+         * app's own runtime token is implicitly granted this for all of its own services.
+         */
+        async runService(target, body, options) {
+            var _a;
+            const { ref, serviceName } = parseServiceTarget(target);
             const queryString = (options === null || options === void 0 ? void 0 : options.query)
                 ? '?' + new URLSearchParams(options.query).toString()
                 : '';
             // @ts-ignore
             const devServiceUrl = isBrowser && ((_a = window.__ENV_VARIABLES__) === null || _a === void 0 ? void 0 : _a.FORGE_DEV_SERVICE_URL);
             if (devServiceUrl) {
-                return axios.post(`${devServiceUrl}/${serviceName}${queryString}`, (_b = options === null || options === void 0 ? void 0 : options.body) !== null && _b !== void 0 ? _b : {}, (options === null || options === void 0 ? void 0 : options.headers) ? { headers: options.headers } : undefined);
+                // The dev service server routes by name; the ref is ignored.
+                return axios.post(`${devServiceUrl}/${serviceName}${queryString}`, body !== null && body !== void 0 ? body : {}, (options === null || options === void 0 ? void 0 : options.headers) ? { headers: options.headers } : undefined);
             }
-            return await this.client.post(`/luma/forge-runtime/api/services/${appUuid}/${serviceName}${queryString}`, (_c = options === null || options === void 0 ? void 0 : options.body) !== null && _c !== void 0 ? _c : {}, (options === null || options === void 0 ? void 0 : options.headers) ? { headers: options.headers } : undefined);
+            if (!ref) {
+                throw new Error("runService: could not resolve the current app from the platform context. " +
+                    "Use a service PRN with an explicit ref: prn:forge:{name|uuid}:service/{serviceName}.");
+            }
+            // Service execution is owned by the forge runtime (forge-runtime gateway ->
+            // platform-forge), which resolves the ref (name → uuid, marketplace → custom)
+            // and executes the service, enforcing `service::{name} forge::{uuid}`
+            // for platform-access services before running.
+            return await this.client.post(`/luma/forge-runtime/api/services/${ref}/${serviceName}${queryString}`, body !== null && body !== void 0 ? body : {}, (options === null || options === void 0 ? void 0 : options.headers) ? { headers: options.headers } : undefined);
         }
     }
 
-    const BASE = '/luma/kortex/v1';
+    const BASE$1 = '/luma/kortex/v1';
     class Kortex extends PlatformBaseClient {
         // ── Agents ──
         async createAgent(data) {
-            return await this.client.post(`${BASE}/agents`, data);
+            return await this.client.post(`${BASE$1}/agents`, data);
         }
         async listAgents(params) {
-            return await this.client.get(`${BASE}/agents`, { params });
+            return await this.client.get(`${BASE$1}/agents`, { params });
         }
         async getAgent(uuid) {
-            return await this.client.get(`${BASE}/agents/${uuid}`);
+            return await this.client.get(`${BASE$1}/agents/${uuid}`);
         }
         async updateAgent(uuid, data) {
-            return await this.client.patch(`${BASE}/agents/${uuid}`, data);
+            return await this.client.patch(`${BASE$1}/agents/${uuid}`, data);
         }
         async deleteAgent(uuid) {
-            return await this.client.delete(`${BASE}/agents/${uuid}`);
+            return await this.client.delete(`${BASE$1}/agents/${uuid}`);
         }
         async listAgentKnowledgeBases(agentUUID) {
-            return await this.client.get(`${BASE}/agents/${agentUUID}/knowledge-bases`);
+            return await this.client.get(`${BASE$1}/agents/${agentUUID}/knowledge-bases`);
         }
         // ── Knowledge Bases ──
         async createKnowledgeBase(data) {
-            return await this.client.post(`${BASE}/knowledge-bases`, data);
+            return await this.client.post(`${BASE$1}/knowledge-bases`, data);
         }
         async listKnowledgeBases(params) {
-            return await this.client.get(`${BASE}/knowledge-bases`, { params });
+            return await this.client.get(`${BASE$1}/knowledge-bases`, { params });
         }
         async getKnowledgeBase(uuid) {
-            return await this.client.get(`${BASE}/knowledge-bases/${uuid}`);
+            return await this.client.get(`${BASE$1}/knowledge-bases/${uuid}`);
         }
         async updateKnowledgeBase(uuid, data) {
-            return await this.client.put(`${BASE}/knowledge-bases/${uuid}`, data);
+            return await this.client.put(`${BASE$1}/knowledge-bases/${uuid}`, data);
         }
         async deleteKnowledgeBase(uuid) {
-            return await this.client.delete(`${BASE}/knowledge-bases/${uuid}`);
+            return await this.client.delete(`${BASE$1}/knowledge-bases/${uuid}`);
+        }
+        // Searches the knowledge bases attached to `data.agent_uuid` (collections
+        // are derived from the agent, not passed explicitly). `top_k` is clamped
+        // to 1-10 server-side. Response is `{ chunks: KnowledgeBaseSearchChunk[] }`.
+        async searchKnowledgeBase(data) {
+            return await this.client.post(`${BASE$1}/knowledge-bases/search`, data);
         }
         // ── Documents ──
         async listDocuments(kbUUID, params) {
-            return await this.client.get(`${BASE}/knowledge-bases/${kbUUID}/documents`, { params });
+            return await this.client.get(`${BASE$1}/knowledge-bases/${kbUUID}/documents`, { params });
         }
         async uploadDocument(kbUUID, formData) {
-            return await this.client.post(`${BASE}/knowledge-bases/${kbUUID}/documents`, formData, {
+            return await this.client.post(`${BASE$1}/knowledge-bases/${kbUUID}/documents`, formData, {
                 headers: { 'Content-Type': 'multipart/form-data' },
                 timeout: 120000,
             });
         }
         async getDocument(kbUUID, uuid) {
-            return await this.client.get(`${BASE}/knowledge-bases/${kbUUID}/documents/${uuid}`);
+            return await this.client.get(`${BASE$1}/knowledge-bases/${kbUUID}/documents/${uuid}`);
         }
         async deleteDocument(kbUUID, uuid) {
-            return await this.client.delete(`${BASE}/knowledge-bases/${kbUUID}/documents/${uuid}`);
+            return await this.client.delete(`${BASE$1}/knowledge-bases/${kbUUID}/documents/${uuid}`);
         }
         async retryDocument(kbUUID, uuid) {
-            return await this.client.post(`${BASE}/knowledge-bases/${kbUUID}/documents/${uuid}/retry`);
+            return await this.client.post(`${BASE$1}/knowledge-bases/${kbUUID}/documents/${uuid}/retry`);
         }
         // ── Conversations ──
         async createConversation(data) {
-            return await this.client.post(`${BASE}/conversations`, data);
+            return await this.client.post(`${BASE$1}/conversations`, data);
         }
         async listConversations(params) {
-            return await this.client.get(`${BASE}/conversations`, { params });
+            return await this.client.get(`${BASE$1}/conversations`, { params });
         }
         async getConversation(uuid) {
-            return await this.client.get(`${BASE}/conversations/${uuid}`);
+            return await this.client.get(`${BASE$1}/conversations/${uuid}`);
         }
         async updateConversation(uuid, data) {
-            return await this.client.put(`${BASE}/conversations/${uuid}`, data);
+            return await this.client.put(`${BASE$1}/conversations/${uuid}`, data);
         }
         async deleteConversation(uuid) {
-            return await this.client.delete(`${BASE}/conversations/${uuid}`);
+            return await this.client.delete(`${BASE$1}/conversations/${uuid}`);
         }
         async archiveConversation(uuid) {
-            return await this.client.post(`${BASE}/conversations/${uuid}/archive`);
+            return await this.client.post(`${BASE$1}/conversations/${uuid}/archive`);
         }
         async unarchiveConversation(uuid) {
-            return await this.client.post(`${BASE}/conversations/${uuid}/unarchive`);
+            return await this.client.post(`${BASE$1}/conversations/${uuid}/unarchive`);
         }
         async addParticipant(conversationUUID, data) {
-            return await this.client.post(`${BASE}/conversations/${conversationUUID}/participants`, data);
+            return await this.client.post(`${BASE$1}/conversations/${conversationUUID}/participants`, data);
         }
         async removeParticipant(conversationUUID, agentUUID) {
-            return await this.client.delete(`${BASE}/conversations/${conversationUUID}/participants/${agentUUID}`);
+            return await this.client.delete(`${BASE$1}/conversations/${conversationUUID}/participants/${agentUUID}`);
         }
         // ── Messages / Completions ──
         async sendMessage(conversationUUID, data) {
-            return await this.client.post(`${BASE}/conversations/${conversationUUID}/messages`, data);
+            return await this.client.post(`${BASE$1}/conversations/${conversationUUID}/messages`, data);
         }
         async streamMessage(conversationUUID, data) {
-            return await this.client.post(`${BASE}/conversations/${conversationUUID}/messages`, { ...data, stream: true }, {
+            return await this.client.post(`${BASE$1}/conversations/${conversationUUID}/messages`, { ...data, stream: true }, {
                 responseType: 'stream',
                 timeout: 120000,
             });
         }
         async listMessages(conversationUUID, params) {
-            return await this.client.get(`${BASE}/conversations/${conversationUUID}/messages`, { params });
+            return await this.client.get(`${BASE$1}/conversations/${conversationUUID}/messages`, { params });
         }
         async injectMessage(conversationUUID, data) {
-            return await this.client.post(`${BASE}/conversations/${conversationUUID}/messages/inject`, data);
+            return await this.client.post(`${BASE$1}/conversations/${conversationUUID}/messages/inject`, data);
         }
         // ── OCR ──
         async ocr(data) {
-            return await this.client.post(`${BASE}/ocr`, data, { timeout: 120000 });
+            return await this.client.post(`${BASE$1}/ocr`, data, { timeout: 120000 });
+        }
+        // ── Workflow ──
+        async workflowComplete(data) {
+            return await this.client.post(`${BASE$1}/workflow/complete`, data);
+        }
+        async workflowOcr(data) {
+            return await this.client.post(`${BASE$1}/workflow/ocr`, data, { timeout: 120000 });
         }
         // ── User Access ──
         async createUserAccess(data) {
-            return await this.client.post(`${BASE}/user-access`, data);
+            return await this.client.post(`${BASE$1}/user-access`, data);
         }
         async listUserAccess(params) {
-            return await this.client.get(`${BASE}/user-access`, { params });
+            return await this.client.get(`${BASE$1}/user-access`, { params });
         }
         async getUserAccess(uuid) {
-            return await this.client.get(`${BASE}/user-access/${uuid}`);
+            return await this.client.get(`${BASE$1}/user-access/${uuid}`);
         }
         async updateUserAccess(uuid, data) {
-            return await this.client.patch(`${BASE}/user-access/${uuid}`, data);
+            return await this.client.patch(`${BASE$1}/user-access/${uuid}`, data);
         }
         async deleteUserAccess(uuid) {
-            return await this.client.delete(`${BASE}/user-access/${uuid}`);
+            return await this.client.delete(`${BASE$1}/user-access/${uuid}`);
         }
         async getUserMonthlyUsage(uuid, params) {
-            return await this.client.get(`${BASE}/user-access/${uuid}/usage`, { params });
+            return await this.client.get(`${BASE$1}/user-access/${uuid}/usage`, { params });
         }
         async getUserUsageBreakdown(uuid) {
-            return await this.client.get(`${BASE}/user-access/${uuid}/usage/breakdown`);
+            return await this.client.get(`${BASE$1}/user-access/${uuid}/usage/breakdown`);
         }
         async getMyAccess() {
-            return await this.client.get(`${BASE}/my-access`);
+            return await this.client.get(`${BASE$1}/my-access`);
         }
         // ── Usage (Admin) ──
         async listUsage(params) {
-            return await this.client.get(`${BASE}/usage`, { params });
+            return await this.client.get(`${BASE$1}/usage`, { params });
         }
         // ── Tier ──
         async getTier() {
-            return await this.client.get(`${BASE}/tier`);
+            return await this.client.get(`${BASE$1}/tier`);
         }
     }
 
@@ -1510,12 +1868,50 @@ var ProtokolSDK010 = (function (exports, axios) {
             return await this.client.patch("/v1/project/archive");
         }
         /**
-         * Invite a user to the project
-         * @param emails Array of emails
-         * @param roles Array of role UUIDs
+         * Invite one or more users to the project.
+         *
+         * `POST /v1/project/invite` only accepts a single `email` per request
+         * (see `InviteToProject` in platform-api's
+         * `internal/project/controllers/invite.go`), so this method issues one
+         * request per entry in `emails`, sequentially, with body
+         * `{ email, role_uuid: roles, subject?, comment? }`.
+         *
+         * Return shape (always a single `AxiosResponse`, so existing callers
+         * that do `(await project.invite(...)).data` keep compiling/working
+         * unchanged):
+         * - Exactly one email: the raw `AxiosResponse` from that single request
+         *   (`.data` is that invite's response body, as before).
+         * - More than one email: a response shaped like the last request's
+         *   `AxiosResponse`, but with `.data` replaced by an array of each
+         *   individual request's `.data`, in the same order as `emails`.
+         *
+         * @param emails Array of email addresses to invite
+         * @param roles Array of role UUIDs to grant every invitee
+         * @param extra Optional subject/comment applied to every invite
          */
-        async invite(emails, roles) {
-            return await this.client.post("/v1/project/invite", { emails: emails.join(","), roles });
+        async invite(emails, roles, extra) {
+            const bodyExtra = {};
+            if ((extra === null || extra === void 0 ? void 0 : extra.subject) !== undefined)
+                bodyExtra.subject = extra.subject;
+            if ((extra === null || extra === void 0 ? void 0 : extra.comment) !== undefined)
+                bodyExtra.comment = extra.comment;
+            const responses = [];
+            for (const email of emails) {
+                const res = await this.client.post("/v1/project/invite", {
+                    email,
+                    role_uuid: roles,
+                    ...bodyExtra,
+                });
+                responses.push(res);
+            }
+            if (responses.length === 1) {
+                return responses[0];
+            }
+            const last = responses[responses.length - 1];
+            return {
+                ...last,
+                data: responses.map((r) => r.data),
+            };
         }
         /**
          * Get list of project invites
@@ -1645,25 +2041,49 @@ var ProtokolSDK010 = (function (exports, axios) {
             return await this.client.get("/v1/project/template/workspace");
         }
         /**
-         * Install a template
-         * @param data Installation data
+         * Install a template.
+         *
+         * `POST /v1/project/template/install` decodes body `TemplateInstall = { id,
+         * data, activation_code }` and resolves the target workspace from the
+         * `X-Workspace-Uuid` request header (not the body) — see platform-api's
+         * `template_install.go`. This method keeps the ergonomic object-arg
+         * signature but maps it onto that contract: `template_id` becomes body
+         * `id`, `workspace_uuid` is sent as the `X-Workspace-Uuid` header, and any
+         * `data`/`activation_code` passed in are forwarded in the body as-is.
+         *
+         * @param data `{ template_id, workspace_uuid, data?, activation_code? }`
          */
         async installTemplate(data) {
-            return await this.client.post("/v1/project/template/install", data);
+            const { template_id, workspace_uuid, ...rest } = data;
+            return await this.client.post("/v1/project/template/install", { id: template_id, ...rest }, { headers: { "X-Workspace-Uuid": workspace_uuid } });
         }
         /**
-         * Uninstall a template
-         * @param data Uninstallation data
+         * Uninstall a template.
+         *
+         * `POST /v1/project/template/uninstall` decodes body `TemplateInstall = {
+         * id, data, activation_code }` and resolves the target workspace from the
+         * `X-Workspace-Uuid` request header (not the body) — see platform-api's
+         * `template_uninstall.go`. See `installTemplate` for the mapping.
+         *
+         * @param data `{ template_id, workspace_uuid, data?, activation_code? }`
          */
         async uninstallTemplate(data) {
-            return await this.client.post("/v1/project/template/uninstall", data);
+            const { template_id, workspace_uuid, ...rest } = data;
+            return await this.client.post("/v1/project/template/uninstall", { id: template_id, ...rest }, { headers: { "X-Workspace-Uuid": workspace_uuid } });
         }
         /**
-         * Upgrade a template
-         * @param data Upgrade data
+         * Upgrade a template.
+         *
+         * `POST /v1/project/template/upgrade` decodes body `TemplateInstall = {
+         * id, data, activation_code }` and resolves the target workspace from the
+         * `X-Workspace-Uuid` request header (not the body) — see platform-api's
+         * `template_upgrade.go`. See `installTemplate` for the mapping.
+         *
+         * @param data `{ template_id, workspace_uuid, data?, activation_code? }`
          */
         async upgradeTemplate(data) {
-            return await this.client.post("/v1/project/template/upgrade", data);
+            const { template_id, workspace_uuid, ...rest } = data;
+            return await this.client.post("/v1/project/template/upgrade", { id: template_id, ...rest }, { headers: { "X-Workspace-Uuid": workspace_uuid } });
         }
     }
 
@@ -1683,62 +2103,6 @@ var ProtokolSDK010 = (function (exports, axios) {
         }
     }
 
-    // apis
-    class Platform extends PlatformBaseClient {
-        getPlatformClient() {
-            return this.client;
-        }
-        getPlatformBaseURL() {
-            var _a;
-            return (_a = this.client.defaults.baseURL) !== null && _a !== void 0 ? _a : "";
-        }
-        apiUser() {
-            return (new APIUser()).setClient(this.client);
-        }
-        function() {
-            return (new Functions()).setClient(this.client);
-        }
-        user() {
-            return (new Users()).setClient(this.client);
-        }
-        app(appType) {
-            return (new Apps(appType)).setClient(this.client);
-        }
-        forge() {
-            return (new Forge()).setClient(this.client);
-        }
-        kortex() {
-            return (new Kortex()).setClient(this.client);
-        }
-        component(ref) {
-            return (new Component(ref)).setClient(this.client);
-        }
-        componentUtils() {
-            return (new ComponentUtils()).setClient(this.client);
-        }
-        ratchet() {
-            return (new Ratchet()).setClient(this.client);
-        }
-        sandbox() {
-            return (new Sandbox()).setClient(this.client);
-        }
-        system() {
-            return (new System()).setClient(this.client);
-        }
-        workflow() {
-            return (new Workflow()).setClient(this.client);
-        }
-        thunder() {
-            return (new Thunder()).setClient(this.client);
-        }
-        project() {
-            return (new Project()).setClient(this.client);
-        }
-        config() {
-            return (new Config()).setClient(this.client);
-        }
-    }
-
     class IntegrationsBaseClient extends BaseClient {
         constructor(options) {
             var _a, _b, _c, _d, _e, _f, _g;
@@ -2617,6 +2981,135 @@ var ProtokolSDK010 = (function (exports, axios) {
                 timeout: 120000
             });
         }
+        // ===================================================================
+        // Backup (Library Export Archives)
+        // ===================================================================
+        /**
+         * Create a library export archive (a snapshot of the project's library or a directory within it)
+         *
+         * The library is resolved server-side from the project in the auth context —
+         * there is a single library per project.
+         *
+         * @param payload - Optional export scope/format options
+         * @returns `{ mode, export }` when the export is queued asynchronously.
+         *   Depending on server-side sizing, the endpoint may instead stream the
+         *   archive back directly as a binary response body (not this JSON shape).
+         *
+         * @example
+         * ```typescript
+         * const result = await dms.createExport({ path: 'legal', format: 'zip' });
+         * ```
+         */
+        async createExport(payload) {
+            return this.request('POST', `library/exports`, { data: payload !== null && payload !== void 0 ? payload : {} });
+        }
+        /**
+         * List export archives for the project's library
+         */
+        async listExports() {
+            return this.request('GET', `library/exports`);
+        }
+        /**
+         * Get a single export archive (an archived snapshot of a library/dir)
+         *
+         * @param exportUuid - Export UUID
+         * @returns `{ export, download_url }`
+         */
+        async getExport(exportUuid) {
+            return this.request('GET', `library/exports/${exportUuid}`);
+        }
+        // ===================================================================
+        // Policies (Quota / File-Type / Notification, library & dir scope)
+        // ===================================================================
+        /**
+         * Get the effective library-level policy for the project's library
+         */
+        async getLibraryPolicy() {
+            return this.request('GET', `library/policy`);
+        }
+        /**
+         * Set/update the library-level policy for the project's library
+         *
+         * @param payload - Policy fields to set
+         */
+        async setLibraryPolicy(payload) {
+            return this.request('PUT', `library/policy`, { data: payload });
+        }
+        /**
+         * Get the directory-level policy (resolves platform-default → library → dir)
+         *
+         * @param path - Directory path
+         */
+        async getDirPolicy(path) {
+            return this.request('GET', `library/dir/policy`, { params: { path } });
+        }
+        /**
+         * Set/update the directory-level policy
+         *
+         * @param path - Directory path
+         * @param payload - Policy fields to set (only fields provided override the library policy)
+         */
+        async setDirPolicy(path, payload) {
+            return this.request('PUT', `library/dir/policy`, { data: payload, params: { path } });
+        }
+        /**
+         * Remove a directory-level policy override (directory falls back to the library policy)
+         *
+         * @param path - Directory path
+         */
+        async deleteDirPolicy(path) {
+            return this.request('DELETE', `library/dir/policy`, { params: { path } });
+        }
+        // ===================================================================
+        // Reminders (Notification Rules & Per-File Notifications)
+        // ===================================================================
+        /**
+         * List notification rules for the project's library
+         */
+        async listNotificationRules() {
+            return this.request('GET', `library/notification-rules`);
+        }
+        /**
+         * Create a recurring reminder (notification rule) for a media file
+         *
+         * @param payload - Recurring reminder definition (media_uuid/file_key, frequency, start_at, ...)
+         */
+        async createNotificationRule(payload) {
+            return this.request('POST', `library/notification-rules`, { data: payload });
+        }
+        /**
+         * Delete a notification rule
+         *
+         * @param ruleUuid - Notification rule UUID
+         */
+        async deleteNotificationRule(ruleUuid) {
+            return this.request('DELETE', `library/notification-rules/${ruleUuid}`);
+        }
+        /**
+         * List custom reminders scheduled for a specific file
+         *
+         * @param mediaUuid - Media UUID
+         */
+        async listFileNotifications(mediaUuid) {
+            return this.request('GET', `library/media/${mediaUuid}/notifications`);
+        }
+        /**
+         * Create a custom reminder for a specific file
+         *
+         * @param mediaUuid - Media UUID
+         * @param payload - Reminder details (note, notify_at, optional recipient)
+         */
+        async createFileNotification(mediaUuid, payload) {
+            return this.request('POST', `library/media/${mediaUuid}/notifications`, { data: payload });
+        }
+        /**
+         * Cancel/delete a custom file reminder
+         *
+         * @param notificationUuid - Notification UUID
+         */
+        async deleteFileNotification(notificationUuid) {
+            return this.request('DELETE', `library/notifications/${notificationUuid}`);
+        }
         async request(method, endpoint, params) {
             return await this.client.request({
                 method: method,
@@ -3786,6 +4279,65 @@ var ProtokolSDK010 = (function (exports, axios) {
             const { data } = await this.client.get("/v1/integrations");
             return data.find((i) => i.id == id && i.status == "active") !== undefined;
         }
+        /**
+         * Install (integrate) an integration into the current project.
+         * POST /v1/integrate
+         */
+        async install(id, data) {
+            const { data: resp } = await this.client.post("/v1/integrate", {
+                id,
+                ...(data !== undefined ? { data } : {}),
+            });
+            return resp;
+        }
+        /**
+         * Uninstall (remove) an integration from the current project.
+         * PUT /v1/integrate
+         */
+        async uninstall(id) {
+            const { data } = await this.client.put("/v1/integrate", { id });
+            return data;
+        }
+        /**
+         * Activate an installed integration.
+         * POST /v1/integration/{id}/activate
+         */
+        async activate(id) {
+            const { data } = await this.client.post(`/v1/integration/${encodeURIComponent(id)}/activate`);
+            return data;
+        }
+        /**
+         * Deactivate an installed integration.
+         * POST /v1/integration/{id}/deactivate
+         */
+        async deactivate(id) {
+            const { data } = await this.client.post(`/v1/integration/${encodeURIComponent(id)}/deactivate`);
+            return data;
+        }
+        /**
+         * Advance/update the onboarding state of an installed integration.
+         * POST /v1/integration/{id}/onboarding
+         */
+        async onboarding(id, data) {
+            const { data: resp } = await this.client.post(`/v1/integration/${encodeURIComponent(id)}/onboarding`, data);
+            return resp;
+        }
+        /**
+         * List marketplace-available integrations (subscription/geo aware).
+         * GET /v1/marketplace/integrations
+         */
+        async marketplace() {
+            const { data } = await this.client.get("/v1/marketplace/integrations");
+            return data;
+        }
+        /**
+         * List explorable integration templates (subscription/geo aware).
+         * GET /v1/integrations/explore
+         */
+        async explore() {
+            const { data } = await this.client.get("/v1/integrations/explore");
+            return data;
+        }
         getInterfaceOf(id) {
             try {
                 return this.integrations[id];
@@ -3798,57 +4350,286 @@ var ProtokolSDK010 = (function (exports, axios) {
 
     class Satellites extends IntegrationsBaseClient {
         async list() {
-            const { data } = await this.client.get('/satellites/templates');
+            const { data } = await this.client.get('/v1/satellites/templates');
             return data;
         }
         async create(payload) {
-            const { data } = await this.client.post('/satellites/templates', payload.template);
+            const { data } = await this.client.post('/v1/satellites/templates', payload.template);
             if (payload.schema) {
                 await this.createVersion(data.id, payload.schema);
             }
             return data;
         }
         async get(id) {
-            const { data } = await this.client.get(`/satellites/templates/${encodeURIComponent(id)}`);
+            const { data } = await this.client.get(`/v1/satellites/templates/${encodeURIComponent(id)}`);
             return data;
         }
         async delete(id) {
-            const { data } = await this.client.delete(`/satellites/templates/${encodeURIComponent(id)}`);
+            const { data } = await this.client.delete(`/v1/satellites/templates/${encodeURIComponent(id)}`);
             return data;
         }
         async createVersion(id, payload) {
-            const { data } = await this.client.post(`/satellites/templates/${encodeURIComponent(id)}/versions`, payload);
+            const { data } = await this.client.post(`/v1/satellites/templates/${encodeURIComponent(id)}/versions`, payload);
             return data;
         }
         async versions(id) {
-            const { data } = await this.client.get(`/satellites/templates/${encodeURIComponent(id)}/versions`);
+            const { data } = await this.client.get(`/v1/satellites/templates/${encodeURIComponent(id)}/versions`);
             return data;
         }
         async deploy(id, payload) {
-            const { data } = await this.client.post(`/satellites/templates/${encodeURIComponent(id)}/deploy`, payload);
+            const { data } = await this.client.post(`/v1/satellites/templates/${encodeURIComponent(id)}/deploy`, payload);
             return data;
         }
         async rollback(id, payload) {
-            const { data } = await this.client.post(`/satellites/templates/${encodeURIComponent(id)}/rollback`, payload);
+            const { data } = await this.client.post(`/v1/satellites/templates/${encodeURIComponent(id)}/rollback`, payload);
             return data;
         }
         async permissions(id) {
-            const { data } = await this.client.get(`/satellites/templates/${encodeURIComponent(id)}/permissions`);
+            const { data } = await this.client.get(`/v1/satellites/templates/${encodeURIComponent(id)}/permissions`);
             return data;
         }
         async logs(id, params = {}) {
             const since = params.since instanceof Date ? params.since.toISOString() : params.since;
-            const { data } = await this.client.get(`/satellites/templates/${encodeURIComponent(id)}/logs`, {
+            const { data } = await this.client.get(`/v1/satellites/templates/${encodeURIComponent(id)}/logs`, {
                 params: since ? { since } : undefined,
             });
             return data;
         }
         async execute(id, command, payload = {}) {
-            const { data } = await this.client.post(`/satellites/${encodeURIComponent(id)}/commands/${encodeURIComponent(command)}/execute`, payload);
+            const { data } = await this.client.post(`/v1/satellites/${encodeURIComponent(id)}/commands/${encodeURIComponent(command)}/execute`, payload);
             return data;
         }
     }
 
+    const BASE = "/luma/transactions/v1";
+    /**
+     * Transactions client — billing/subscriptions, invoices, credits/balance,
+     * usage pricing and per-project billing-mode overrides. All routes go
+     * through the `transactions/…` gateway prefix (`/luma/transactions/v1/...`),
+     * matching the transactions service's REST surface
+     * (`internal/controllers/{subscription,invoices,topup,credit_history,billing_modes,prices,balance}.go`).
+     *
+     * This is the **billing** service — not distributed/database transactions.
+     */
+    class Transactions extends PlatformBaseClient {
+        // ---------------------------------------------------------------
+        // Subscriptions
+        // ---------------------------------------------------------------
+        /**
+         * List all subscriptions (including expired) for the current project.
+         *
+         * @example
+         * const subs = await platform.transactions().getSubscriptions()
+         */
+        async getSubscriptions() {
+            return await this.client.get(`${BASE}/billing/subscription`);
+        }
+        /**
+         * Renew an expired subscription (and any others sharing its bundle
+         * `ref_no`) — creates a renewal invoice and returns a checkout link.
+         */
+        async renewSubscription(payload) {
+            return await this.client.post(`${BASE}/subscription/renew`, payload);
+        }
+        /**
+         * Cancel a subscription. Issues a refund automatically if still within
+         * the refund period.
+         */
+        async cancelSubscription(payload) {
+            return await this.client.post(`${BASE}/subscription/cancel`, payload);
+        }
+        // ---------------------------------------------------------------
+        // Invoices
+        // ---------------------------------------------------------------
+        /**
+         * List all invoices for the current project.
+         */
+        async getInvoices() {
+            return await this.client.get(`${BASE}/billing/invoices`);
+        }
+        /**
+         * Get a single invoice by uuid.
+         */
+        async getInvoice(uuid) {
+            return await this.client.get(`${BASE}/billing/invoice/${uuid}`);
+        }
+        /**
+         * Download an invoice as a PDF. Resolves with the raw PDF bytes
+         * (`responseType: "arraybuffer"`).
+         *
+         * @example
+         * const { data } = await platform.transactions().getInvoicePdf(uuid)
+         * fs.writeFileSync("invoice.pdf", Buffer.from(data))
+         */
+        async getInvoicePdf(uuid) {
+            return await this.client.get(`${BASE}/billing/invoice/${uuid}/pdf`, {
+                responseType: "arraybuffer",
+            });
+        }
+        // ---------------------------------------------------------------
+        // Balance / credits / top-up
+        // ---------------------------------------------------------------
+        /**
+         * Get the current project's credit balance.
+         */
+        async getBalance() {
+            return await this.client.get(`${BASE}/billing/balance`);
+        }
+        /**
+         * Generate a checkout link to manually top up the project's credit balance.
+         */
+        async topUp(payload) {
+            return await this.client.post(`${BASE}/billing/topup`, payload);
+        }
+        /**
+         * Get the project's credit activity (deductions/top-ups) history, paginated.
+         */
+        async getCreditsHistory(query) {
+            return await this.client.get(`${BASE}/billing/credits/history`, {
+                params: query,
+            });
+        }
+        // ---------------------------------------------------------------
+        // Prices
+        // ---------------------------------------------------------------
+        /**
+         * Get the usage-based pricing table for a given currency.
+         *
+         * @param currency - ISO 4217 currency code, e.g. "USD" or "RSD".
+         */
+        async getPrices(currency) {
+            return await this.client.get(`${BASE}/prices/${currency}`);
+        }
+        // ---------------------------------------------------------------
+        // Billing modes (per-project usage billing overrides)
+        // ---------------------------------------------------------------
+        /**
+         * Get the project's usage-billing-mode overrides plus platform defaults.
+         */
+        async getBillingModes() {
+            return await this.client.get(`${BASE}/billing/billing-modes`);
+        }
+        /**
+         * Set the billing mode ("credits" | "hybrid" | "invoice") for a usage
+         * option code on the current project.
+         */
+        async updateBillingModes(payload) {
+            return await this.client.put(`${BASE}/billing/billing-modes`, payload);
+        }
+    }
+
+    // apis
+    class Platform extends PlatformBaseClient {
+        getPlatformClient() {
+            return this.client;
+        }
+        getPlatformBaseURL() {
+            var _a;
+            return (_a = this.client.defaults.baseURL) !== null && _a !== void 0 ? _a : "";
+        }
+        apiUser() {
+            return (new APIUser()).setClient(this.client);
+        }
+        function() {
+            return (new Functions()).setClient(this.client);
+        }
+        user() {
+            return (new Users()).setClient(this.client);
+        }
+        app(appType) {
+            return (new Apps(appType)).setClient(this.client);
+        }
+        forge() {
+            return (new Forge()).setClient(this.client);
+        }
+        kortex() {
+            return (new Kortex()).setClient(this.client);
+        }
+        component(ref) {
+            return (new Component(ref)).setClient(this.client);
+        }
+        componentUtils() {
+            return (new ComponentUtils()).setClient(this.client);
+        }
+        ratchet() {
+            return (new Ratchet()).setClient(this.client);
+        }
+        sandbox() {
+            return (new Sandbox()).setClient(this.client);
+        }
+        system() {
+            return (new System()).setClient(this.client);
+        }
+        workflow() {
+            return (new Workflow()).setClient(this.client);
+        }
+        thunder() {
+            return (new Thunder()).setClient(this.client);
+        }
+        project() {
+            return (new Project()).setClient(this.client);
+        }
+        config() {
+            return (new Config()).setClient(this.client);
+        }
+        /**
+         * Convenience factory for the Integrations gateway façade.
+         *
+         * Integrations live behind a different gateway (`INTEGRATION_API` /
+         * `host/luma/integrations`) than the rest of the platform API, so this
+         * returns an independently-configured `Integrations` client (it does not
+         * reuse `this.client`, whose base URL points at the platform host). The
+         * Platform's resolved token/env/host are propagated so the child client
+         * carries the same credentials.
+         */
+        integrations() {
+            return new Integrations(this.getIntegrationsGatewayOptions());
+        }
+        /**
+         * Convenience factory for the Satellites (custom JSON-RPC integrations) client.
+         *
+         * Same gateway note as `integrations()` — Satellites talks to the
+         * integrations gateway, not the platform host, so a fresh, independently
+         * configured client is returned, with the Platform's credentials propagated.
+         */
+        satellites() {
+            return new Satellites(this.getIntegrationsGatewayOptions());
+        }
+        /**
+         * Builds the options for a child integrations-gateway client (`Integrations`/
+         * `Satellites`), propagating this Platform's resolved token/env, and deriving
+         * the gateway host from this Platform's host when one was explicitly set.
+         * When `this.host` is unset, `host` is left `undefined` so the child client's
+         * own env-var/default resolution applies.
+         */
+        getIntegrationsGatewayOptions() {
+            var _a, _b;
+            return {
+                token: (_a = this.token) !== null && _a !== void 0 ? _a : undefined,
+                env: (_b = this.env) !== null && _b !== void 0 ? _b : undefined,
+                host: this.host ? `${this.host.replace(/\/+$/, "")}/luma/integrations` : undefined,
+            };
+        }
+        /**
+         * Transactions (billing) client — subscriptions, invoices, credits/balance,
+         * usage pricing and billing-mode overrides. Reached through the platform
+         * gateway (`transactions/…`), so it reuses `this.client` like the other
+         * native/proxied-service factories.
+         *
+         * This is the **billing** service — not distributed/database transactions.
+         */
+        transactions() {
+            return (new Transactions()).setClient(this.client);
+        }
+        /**
+         * Alias for `transactions()` — reads more naturally at call sites that
+         * only care about billing (`platform.billing().getBalance()`).
+         */
+        billing() {
+            return this.transactions();
+        }
+    }
+
     // PRN — Protokol Resource Name
     //
     // Format:
@@ -4027,6 +4808,7 @@ var ProtokolSDK010 = (function (exports, axios) {
     exports.System = System;
     exports.Thunder = Thunder;
     exports.Timber = Timber;
+    exports.Transactions = Transactions;
     exports.Users = Users;
     exports.VPFR = VPFR;
     exports.Workflow = Workflow;