@ptkl/sdk 1.9.2 → 1.11.0

package/dist/v0.10/api/thunder.d.ts

@@ -1,11 +1,12 @@
 import PlatformBaseClient from "./platformBaseClient";
+import type { ThunderReadOptions } from "../types/thunder";
 export default class Thunder extends PlatformBaseClient {
-    read(type: string, filters: any, flag: string, options?: any, only?: string[]): Promise<import("axios").AxiosResponse<any, any>>;
+    read(type: string, filters: any, flag: string, opts?: ThunderReadOptions): Promise<import("axios").AxiosResponse<any, any>>;
     write(type: string, filters: any, d: any, flag: any): Promise<import("axios").AxiosResponse<any, any>>;
     operation(name: string, filters: any, data: any): Promise<import("axios").AxiosResponse<any, any>>;
-    find(name: string, filters: any, only?: string[]): Promise<import("axios").AxiosResponse<any, any>>;
-    findOne(name: string, filters: any, only?: string[]): Promise<import("axios").AxiosResponse<any, any>>;
-    paginate(name: string, filters: any, options?: any, only?: string[]): Promise<import("axios").AxiosResponse<any, any>>;
+    find(name: string, filters: any, options?: ThunderReadOptions): Promise<import("axios").AxiosResponse<any, any>>;
+    findOne(name: string, filters: any, options?: ThunderReadOptions): Promise<import("axios").AxiosResponse<any, any>>;
+    paginate(name: string, filters: any, options?: ThunderReadOptions): Promise<import("axios").AxiosResponse<any, any>>;
     upsert(name: string, filters: any, data: any): Promise<import("axios").AxiosResponse<any, any>>;
     insertOne(name: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
     updateOne(name: string, filters: any, data: any): Promise<import("axios").AxiosResponse<any, any>>;

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

@@ -19079,77 +19079,60 @@ class Component extends PlatformBaseClient {
         super();
         this.ref = ref;
     }
-    /**
-     * Find method to search for models
-     *
-     * @param {FindParams} filters - The filters to apply to the search
-     * @param {FindOptions} opts - The options to apply to the search
-     *
-     * @returns {Promise<FindResponse>} - The result of the search
-     *
-     * @example
-     * platform.component(name).find({
-     *     currentPage: 1,
-     *     perPage: 10,
-     * })
-     *
-     * // advanced search
-     * platform.component(name).find({
-     *     $adv: {
-     *         name: "John Doe",
-     *     }
-     * )
-     **/
-    async find(filters, opts) {
-        var _a;
-        let payload = {
-            context: filters,
-            ref: this.ref,
-        };
-        let ctx = payload.context;
-        let offset = ctx.currentPage;
-        if (offset == undefined) {
-            offset = 0;
-        }
-        let limit = ctx.perPage;
-        if (limit == undefined || limit == -1) {
-            limit = 10;
-        }
-        let sortDesc = 1;
-        if (ctx.sortDesc) {
-            sortDesc = -1;
-        }
-        if (ctx.filterOn === undefined) {
-            ctx.filterOn = [];
-        }
-        let params = {
-            offset: offset,
-            sortBy: ctx.sortBy,
-            sortDesc: sortDesc,
-            filter: ctx.filter,
-            filterOn: ctx.filterOn,
-            limit: limit,
-            dateFrom: ctx.dateFrom,
-            dateTo: ctx.dateTo,
-            dateField: ctx.dateField,
-        };
-        if (ctx.only && ctx.only.length > 0) {
-            params.only = ctx.only;
-        }
-        else if (ctx.includeFields && ctx.includeFields.length > 0) {
-            // Backward-compatible alias. The API now prefers `only`.
-            params.includeFields = ctx.includeFields;
-        }
-        if (Object.keys(ctx.$adv || []).length > 0) {
-            params.$adv = [(_a = ctx.$adv) !== null && _a !== void 0 ? _a : {}];
-        }
-        if (ctx.$aggregate && ctx.$aggregate.length > 0) {
-            params.$aggregate = ctx.$aggregate;
+    find(filters, opts) {
+        if (opts && opts.stream === true) {
+            let onMetaCallback = () => { };
+            let onDataCallback = () => { };
+            let onErrorCallback;
+            let onEndCallback;
+            let isFirstLine = true;
+            const chainable = {
+                onMeta: (callback) => {
+                    onMetaCallback = callback;
+                    return chainable;
+                },
+                onData: (callback) => {
+                    onDataCallback = callback;
+                    return chainable;
+                },
+                onError: (callback) => {
+                    onErrorCallback = callback;
+                    return chainable;
+                },
+                onEnd: (callback) => {
+                    onEndCallback = callback;
+                    return chainable;
+                },
+                stream: () => {
+                    const body = this._buildFindBody(filters, opts);
+                    const handler = {
+                        onData: async (doc) => {
+                            if (isFirstLine) {
+                                isFirstLine = false;
+                                const result = onMetaCallback(doc);
+                                if (result instanceof Promise)
+                                    await result;
+                            }
+                            else {
+                                const result = onDataCallback(doc);
+                                if (result instanceof Promise)
+                                    await result;
+                            }
+                        },
+                        onError: onErrorCallback,
+                        onEnd: onEndCallback,
+                    };
+                    return this._streamNDJSON(`/v4/system/component/${this.ref}/models/stream`, {
+                        'Accept': 'application/x-ndjson',
+                        'Content-Type': 'application/json',
+                        'Accept-Language': (opts === null || opts === void 0 ? void 0 : opts.locale) || 'en_US',
+                    }, handler, body);
+                }
+            };
+            return chainable;
         }
-        return await this.client.post(`/v4/system/component/${this.ref}/models`, {
-            ...params,
-            options: opts
-        }, {
+        const body = this._buildFindBody(filters, opts);
+        return this.client.post(`/v4/system/component/${this.ref}/models`, body, {
             headers: {
                 "Accept-Language": (opts === null || opts === void 0 ? void 0 : opts.locale) || "en_US",
             }
@@ -19178,6 +19161,34 @@ class Component extends PlatformBaseClient {
         }
         return null;
     }
+    /** @private Build the POST body shared by `find` (streaming and non-streaming) */
+    _buildFindBody(filters, opts) {
+        var _a, _b;
+        let ctx = { ...filters };
+        let offset = (_a = ctx.currentPage) !== null && _a !== void 0 ? _a : 0;
+        let limit = (ctx.perPage == null || ctx.perPage === -1) ? 10 : ctx.perPage;
+        let sortDesc = ctx.sortDesc ? -1 : 1;
+        if (ctx.filterOn === undefined)
+            ctx.filterOn = [];
+        const params = {
+            offset,
+            sortBy: ctx.sortBy,
+            sortDesc,
+            filter: ctx.filter,
+            filterOn: ctx.filterOn,
+            limit,
+            dateFrom: ctx.dateFrom,
+            dateTo: ctx.dateTo,
+            dateField: ctx.dateField,
+        };
+        if (ctx.only && ctx.only.length > 0)
+            params.only = ctx.only;
+        if (Object.keys(ctx.$adv || {}).length > 0)
+            params.$adv = [(_b = ctx.$adv) !== null && _b !== void 0 ? _b : {}];
+        if (ctx.$aggregate && ctx.$aggregate.length > 0)
+            params.$aggregate = ctx.$aggregate;
+        return { ...params, options: opts };
+    }
     /**
      * Get model by uuid
      *
@@ -19927,12 +19938,13 @@ class ComponentUtils extends PlatformBaseClient {
 }
 
 class Thunder extends PlatformBaseClient {
-    async read(type, filters, flag, options, only) {
+    async read(type, filters, flag, opts) {
+        const { only, ...options } = opts !== null && opts !== void 0 ? opts : {};
         return await this.client.post("/v3/system/thunder", {
             type,
             filters,
             flag,
-            options,
+            options: Object.keys(options).length ? options : undefined,
             only,
         });
     }
@@ -19947,14 +19959,14 @@ class Thunder extends PlatformBaseClient {
     async operation(name, filters, data) {
         return await this.write(name, filters, data, "Operation");
     }
-    async find(name, filters, only) {
-        return await this.read(name, filters, "Find", undefined, only);
+    async find(name, filters, options) {
+        return await this.read(name, filters, "Find", options);
     }
-    async findOne(name, filters, only) {
-        return await this.read(name, filters, "FindOne", undefined, only);
+    async findOne(name, filters, options) {
+        return await this.read(name, filters, "FindOne", options);
     }
-    async paginate(name, filters, options, only) {
-        return await this.read(name, filters, "Paginate", options, only);
+    async paginate(name, filters, options) {
+        return await this.read(name, filters, "Paginate", options);
     }
     async upsert(name, filters, data) {
         return await this.write(name, filters, data, "Upsert");
@@ -20262,6 +20274,145 @@ class Forge extends PlatformBaseClient {
     }
 }
 
+const BASE = '/luma/kortex/v1';
+class Kortex extends PlatformBaseClient {
+    // ── Agents ──
+    async createAgent(data) {
+        return await this.client.post(`${BASE}/agents`, data);
+    }
+    async listAgents(params) {
+        return await this.client.get(`${BASE}/agents`, { params });
+    }
+    async getAgent(uuid) {
+        return await this.client.get(`${BASE}/agents/${uuid}`);
+    }
+    async updateAgent(uuid, data) {
+        return await this.client.patch(`${BASE}/agents/${uuid}`, data);
+    }
+    async deleteAgent(uuid) {
+        return await this.client.delete(`${BASE}/agents/${uuid}`);
+    }
+    async listAgentKnowledgeBases(agentUUID) {
+        return await this.client.get(`${BASE}/agents/${agentUUID}/knowledge-bases`);
+    }
+    // ── Knowledge Bases ──
+    async createKnowledgeBase(data) {
+        return await this.client.post(`${BASE}/knowledge-bases`, data);
+    }
+    async listKnowledgeBases(params) {
+        return await this.client.get(`${BASE}/knowledge-bases`, { params });
+    }
+    async getKnowledgeBase(uuid) {
+        return await this.client.get(`${BASE}/knowledge-bases/${uuid}`);
+    }
+    async updateKnowledgeBase(uuid, data) {
+        return await this.client.put(`${BASE}/knowledge-bases/${uuid}`, data);
+    }
+    async deleteKnowledgeBase(uuid) {
+        return await this.client.delete(`${BASE}/knowledge-bases/${uuid}`);
+    }
+    // ── Documents ──
+    async listDocuments(kbUUID, params) {
+        return await this.client.get(`${BASE}/knowledge-bases/${kbUUID}/documents`, { params });
+    }
+    async uploadDocument(kbUUID, formData) {
+        return await this.client.post(`${BASE}/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}`);
+    }
+    async deleteDocument(kbUUID, uuid) {
+        return await this.client.delete(`${BASE}/knowledge-bases/${kbUUID}/documents/${uuid}`);
+    }
+    async retryDocument(kbUUID, uuid) {
+        return await this.client.post(`${BASE}/knowledge-bases/${kbUUID}/documents/${uuid}/retry`);
+    }
+    // ── Conversations ──
+    async createConversation(data) {
+        return await this.client.post(`${BASE}/conversations`, data);
+    }
+    async listConversations(params) {
+        return await this.client.get(`${BASE}/conversations`, { params });
+    }
+    async getConversation(uuid) {
+        return await this.client.get(`${BASE}/conversations/${uuid}`);
+    }
+    async updateConversation(uuid, data) {
+        return await this.client.put(`${BASE}/conversations/${uuid}`, data);
+    }
+    async deleteConversation(uuid) {
+        return await this.client.delete(`${BASE}/conversations/${uuid}`);
+    }
+    async archiveConversation(uuid) {
+        return await this.client.post(`${BASE}/conversations/${uuid}/archive`);
+    }
+    async unarchiveConversation(uuid) {
+        return await this.client.post(`${BASE}/conversations/${uuid}/unarchive`);
+    }
+    async addParticipant(conversationUUID, data) {
+        return await this.client.post(`${BASE}/conversations/${conversationUUID}/participants`, data);
+    }
+    async removeParticipant(conversationUUID, agentUUID) {
+        return await this.client.delete(`${BASE}/conversations/${conversationUUID}/participants/${agentUUID}`);
+    }
+    // ── Messages / Completions ──
+    async sendMessage(conversationUUID, data) {
+        return await this.client.post(`${BASE}/conversations/${conversationUUID}/messages`, data);
+    }
+    async streamMessage(conversationUUID, data) {
+        return await this.client.post(`${BASE}/conversations/${conversationUUID}/messages`, { ...data, stream: true }, {
+            responseType: 'stream',
+            timeout: 120000,
+        });
+    }
+    async listMessages(conversationUUID, params) {
+        return await this.client.get(`${BASE}/conversations/${conversationUUID}/messages`, { params });
+    }
+    async injectMessage(conversationUUID, data) {
+        return await this.client.post(`${BASE}/conversations/${conversationUUID}/messages/inject`, data);
+    }
+    // ── OCR ──
+    async ocr(data) {
+        return await this.client.post(`${BASE}/ocr`, data, { timeout: 120000 });
+    }
+    // ── User Access ──
+    async createUserAccess(data) {
+        return await this.client.post(`${BASE}/user-access`, data);
+    }
+    async listUserAccess(params) {
+        return await this.client.get(`${BASE}/user-access`, { params });
+    }
+    async getUserAccess(uuid) {
+        return await this.client.get(`${BASE}/user-access/${uuid}`);
+    }
+    async updateUserAccess(uuid, data) {
+        return await this.client.patch(`${BASE}/user-access/${uuid}`, data);
+    }
+    async deleteUserAccess(uuid) {
+        return await this.client.delete(`${BASE}/user-access/${uuid}`);
+    }
+    async getUserMonthlyUsage(uuid, params) {
+        return await this.client.get(`${BASE}/user-access/${uuid}/usage`, { params });
+    }
+    async getUserUsageBreakdown(uuid) {
+        return await this.client.get(`${BASE}/user-access/${uuid}/usage/breakdown`);
+    }
+    async getMyAccess() {
+        return await this.client.get(`${BASE}/my-access`);
+    }
+    // ── Usage (Admin) ──
+    async listUsage(params) {
+        return await this.client.get(`${BASE}/usage`, { params });
+    }
+    // ── Tier ──
+    async getTier() {
+        return await this.client.get(`${BASE}/tier`);
+    }
+}
+
 class Project extends PlatformBaseClient {
     /**
      * Get list of all projects for the current user
@@ -20486,6 +20637,9 @@ class Platform extends PlatformBaseClient {
     forge() {
         return (new Forge()).setClient(this.client);
     }
+    kortex() {
+        return (new Kortex()).setClient(this.client);
+    }
     component(ref) {
         return (new Component(ref)).setClient(this.client);
     }
@@ -20852,6 +21006,12 @@ class DMS extends IntegrationsBaseClient {
     async generateDocument(payload) {
         return this.requestv2('POST', 'documents/document/generate', { data: payload });
     }
+    async listDocumentRevisions(path) {
+        return this.requestv2('GET', `documents/revisions/${path}`);
+    }
+    async getDocumentRevision(path, version) {
+        return this.requestv2('GET', `documents/revision/${path}`, { params: { version } });
+    }
     async fillPdf(data) {
         const { input_path, output_path, output_pdf = false, output_type, output_file_name, replace, form_data, forms } = data;
         const responseType = output_pdf ? 'arraybuffer' : 'json';
@@ -22398,6 +22558,45 @@ class Ecommerce extends IntegrationsBaseClient {
     }
 }
 
+class Timber extends IntegrationsBaseClient {
+    async query(params = {}) {
+        const { data } = await this.client.get("/v1/timber/logs", {
+            params: this.normalizeParams(params),
+        });
+        return data;
+    }
+    async write(payload) {
+        const { data } = await this.client.post("/v1/timber/logs", payload);
+        return data;
+    }
+    async usage() {
+        const { data } = await this.client.get("/v1/timber/usage");
+        return data;
+    }
+    async debug(message, payload) {
+        return this.write({ ...payload, message, level: 'debug' });
+    }
+    async info(message, payload) {
+        return this.write({ ...payload, message, level: 'info' });
+    }
+    async warn(message, payload) {
+        return this.write({ ...payload, message, level: 'warn' });
+    }
+    async error(message, payload) {
+        return this.write({ ...payload, message, level: 'error' });
+    }
+    normalizeParams(params) {
+        const normalized = { ...params };
+        if (params.from instanceof Date) {
+            normalized.from = params.from.toISOString();
+        }
+        if (params.to instanceof Date) {
+            normalized.to = params.to.toISOString();
+        }
+        return normalized;
+    }
+}
+
 class Integrations extends IntegrationsBaseClient {
     constructor(options) {
         super(options);
@@ -22409,6 +22608,7 @@ class Integrations extends IntegrationsBaseClient {
             'protokol-payments': new Payments().setClient(this.client),
             'protokol-minimax': new Minimax().setClient(this.client),
             'protokol-ecommerce': new Ecommerce().setClient(this.client),
+            'protokol-timber': new Timber().setClient(this.client),
         };
     }
     getDMS() {
@@ -22435,6 +22635,9 @@ class Integrations extends IntegrationsBaseClient {
     getEcommerce() {
         return this.getInterfaceOf('protokol-ecommerce');
     }
+    getTimber() {
+        return this.getInterfaceOf('protokol-timber');
+    }
     async list() {
         const { data } = await this.client.get("/v1/integrations");
         return data;
@@ -22621,6 +22824,7 @@ exports.Functions = Functions;
 exports.Integration = Integrations;
 exports.Integrations = Integrations;
 exports.Invoicing = Invoicing;
+exports.Kortex = Kortex;
 exports.Mail = Mail;
 exports.NBS = NBS;
 exports.PRN = PRN;
@@ -22632,6 +22836,7 @@ exports.Sandbox = Sandbox;
 exports.SerbiaMinFin = MinFin;
 exports.System = System;
 exports.Thunder = Thunder;
+exports.Timber = Timber;
 exports.Users = Users;
 exports.VPFR = VPFR;
 exports.Workflow = Workflow;