@ptkl/sdk 1.13.0 → 1.15.0

package/dist/v0.10/index.esm.js

@@ -99,6 +99,9 @@ class PlatformBaseClient extends BaseClient {
         this.env = null;
         this.token = null;
         this.host = null;
+        this.env = env;
+        this.token = token;
+        this.host = host;
     }
 }
 
@@ -116,6 +119,7 @@ class Component extends PlatformBaseClient {
         if (opts && opts.stream === true) {
             let onMetaCallback = () => { };
             let onDataCallback = () => { };
+            let onCursorCallback = () => { };
             let onErrorCallback;
             let onEndCallback;
             let isFirstLine = true;
@@ -128,6 +132,10 @@ class Component extends PlatformBaseClient {
                     onDataCallback = callback;
                     return chainable;
                 },
+                onCursor: (callback) => {
+                    onCursorCallback = callback;
+                    return chainable;
+                },
                 onError: (callback) => {
                     onErrorCallback = callback;
                     return chainable;
@@ -146,6 +154,11 @@ class Component extends PlatformBaseClient {
                                 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)
@@ -216,6 +229,8 @@ class Component extends PlatformBaseClient {
         };
         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)
@@ -882,11 +897,32 @@ class Users extends PlatformBaseClient {
     }
     // 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
      */
@@ -971,7 +1007,7 @@ class ComponentUtils extends PlatformBaseClient {
      * @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);
     }
 }
 
@@ -1227,9 +1263,22 @@ class Ratchet extends PlatformBaseClient {
     }
 }
 
+/**
+ * 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
@@ -1241,6 +1290,143 @@ class Sandbox extends PlatformBaseClient {
     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 {
@@ -1268,6 +1454,17 @@ class System extends PlatformBaseClient {
     }
 }
 
+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);
@@ -1290,8 +1487,123 @@ class Workflow extends PlatformBaseClient {
     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) {
@@ -1329,156 +1641,202 @@ class Forge extends PlatformBaseClient {
         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`);
     }
 }
 
@@ -1509,12 +1867,50 @@ class Project extends PlatformBaseClient {
         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
@@ -1644,25 +2040,49 @@ class Project extends PlatformBaseClient {
         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 } });
     }
 }
 
@@ -1682,62 +2102,6 @@ class Config extends PlatformBaseClient {
     }
 }
 
-// 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;
@@ -2616,6 +2980,135 @@ class DMS extends IntegrationsBaseClient {
             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,
@@ -3785,6 +4278,65 @@ class Integrations extends IntegrationsBaseClient {
         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];
@@ -3797,57 +4349,286 @@ class Integrations extends IntegrationsBaseClient {
 
 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:
@@ -4000,4 +4781,4 @@ class Invoicing extends PlatformBaseClient {
     }
 }
 
-export { APIUser, Apps, Component, ComponentUtils, Config, DMS, Ecommerce, Forge, Functions, Integrations as Integration, Integrations, Invoicing, Kortex, Mail, NBS, PRN, Payments, Platform, Project, Ratchet, Sandbox, Satellites, MinFin as SerbiaMinFin, System, Thunder, Timber, Users, VPFR, Workflow, parsePRN };
+export { APIUser, Apps, Component, ComponentUtils, Config, DMS, Ecommerce, Forge, Functions, Integrations as Integration, Integrations, Invoicing, Kortex, Mail, NBS, PRN, Payments, Platform, Project, Ratchet, Sandbox, Satellites, MinFin as SerbiaMinFin, System, Thunder, Timber, Transactions, Users, VPFR, Workflow, parsePRN };