@ptkl/sdk 1.9.2 → 1.11.0

package/dist/index.0.10.js

@@ -113,77 +113,60 @@ var ProtokolSDK010 = (function (exports, axios) {
             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",
                 }
@@ -212,6 +195,34 @@ var ProtokolSDK010 = (function (exports, axios) {
             }
             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
          *
@@ -961,12 +972,13 @@ var ProtokolSDK010 = (function (exports, axios) {
     }
 
     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,
             });
         }
@@ -981,14 +993,14 @@ var ProtokolSDK010 = (function (exports, axios) {
         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");
@@ -1296,6 +1308,145 @@ var ProtokolSDK010 = (function (exports, axios) {
         }
     }
 
+    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
@@ -1520,6 +1671,9 @@ var ProtokolSDK010 = (function (exports, axios) {
         forge() {
             return (new Forge()).setClient(this.client);
         }
+        kortex() {
+            return (new Kortex()).setClient(this.client);
+        }
         component(ref) {
             return (new Component(ref)).setClient(this.client);
         }
@@ -1886,6 +2040,12 @@ var ProtokolSDK010 = (function (exports, axios) {
         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';
@@ -3432,6 +3592,45 @@ var ProtokolSDK010 = (function (exports, axios) {
         }
     }
 
+    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);
@@ -3443,6 +3642,7 @@ var ProtokolSDK010 = (function (exports, axios) {
                 '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() {
@@ -3469,6 +3669,9 @@ var ProtokolSDK010 = (function (exports, axios) {
         getEcommerce() {
             return this.getInterfaceOf('protokol-ecommerce');
         }
+        getTimber() {
+            return this.getInterfaceOf('protokol-timber');
+        }
         async list() {
             const { data } = await this.client.get("/v1/integrations");
             return data;
@@ -3655,6 +3858,7 @@ var ProtokolSDK010 = (function (exports, axios) {
     exports.Integration = Integrations;
     exports.Integrations = Integrations;
     exports.Invoicing = Invoicing;
+    exports.Kortex = Kortex;
     exports.Mail = Mail;
     exports.NBS = NBS;
     exports.PRN = PRN;
@@ -3666,6 +3870,7 @@ var ProtokolSDK010 = (function (exports, axios) {
     exports.SerbiaMinFin = MinFin;
     exports.System = System;
     exports.Thunder = Thunder;
+    exports.Timber = Timber;
     exports.Users = Users;
     exports.VPFR = VPFR;
     exports.Workflow = Workflow;

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ptkl/sdk",
-  "version": "1.9.2",
+  "version": "1.11.0",
   "scripts": {
     "build": "rollup -c",
     "build:monaco": "npm run build && node scripts/generate-monaco-types.cjs",

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

@@ -1,4 +1,4 @@
-import { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, StreamHandler, AggregateChainable, ComponentOptions, UpdateManyOptions, CreateManyOptions, Extension, Policy } from "../types/component";
+import { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, StreamHandler, AggregateChainable, FindChainable, FindStreamMeta, FindStreamMetaCallback, ComponentOptions, UpdateManyOptions, CreateManyOptions, Extension, Policy } from "../types/component";
 import PlatformBaseClient from "./platformBaseClient";
 import { AxiosResponse } from "axios";
 import type { ComponentModels, ComponentFunctions } from "../types/functions";
@@ -38,6 +38,9 @@ export default class Component<C extends string = string> extends PlatformBaseCl
      *     }
      * )
      **/
+    find(filters: FindParams, opts: FindOptions & {
+        stream: true;
+    }): FindChainable;
     find(filters: FindParams, opts?: FindOptions): Promise<AxiosResponse<{
         items: ComponentModel<C>[];
         total: number;
@@ -58,6 +61,8 @@ export default class Component<C extends string = string> extends PlatformBaseCl
      * })
      **/
     findOne(filter: FindAdvancedParams, opts?: FindOptions): Promise<ComponentModel<C> | null>;
+    /** @private Build the POST body shared by `find` (streaming and non-streaming) */
+    private _buildFindBody;
     /**
      * Get model by uuid
      *
@@ -323,4 +328,4 @@ export default class Component<C extends string = string> extends PlatformBaseCl
      */
     private _streamNDJSONNode;
 }
-export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, StreamHandler, AggregateChainable, ComponentOptions, Extension, };
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, StreamHandler, AggregateChainable, FindChainable, FindStreamMeta, FindStreamMetaCallback, ComponentOptions, Extension, };

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

@@ -1,6 +1,8 @@
 export type { PlatformFunctions, PlatformFunction, FunctionInput, FunctionOutput, FunctionCallParams, ComponentModels, ComponentFunctions, ComponentModel, ComponentFunctionInput, ComponentFunctionOutput, } from '../types/functions';
 export type { Settings, SettingsField, FieldRoles, FieldConstraints, Context, Preset, PresetContext, Filters, Extension, Policy, SetupData, Model, } from '../types/component';
 export type { WorkflowModel, WorkflowSettings, WorkflowNode, WorkflowNodeConnection, WorkflowCreatePayload, WorkflowUpdatePayload, WorkflowListResponse, } from '../types/workflow';
+export type { PagedResponse as KortexPagedResponse, PaginationParams as KortexPaginationParams, RAGConfig, LLMSettings, Agent, AgentCreatePayload, AgentUpdatePayload, ChunkingStrategy, KnowledgeBase, KnowledgeBaseCreatePayload, KnowledgeBaseUpdatePayload, Document as KortexDocument, Participant, TokenUsage, ToolCall, RAGSource, Message as KortexMessage, Conversation, ConversationCreatePayload, ConversationUpdatePayload, ParticipantAddPayload, ToolResultPayload, PageContext, SendMessagePayload, InjectMessagePayload, OCRPayload, OCRResult, UserAccess, UserAccessCreatePayload, UserAccessUpdatePayload, TopUpPayload, UserMonthlyUsage, UserUsageBreakdown, MyAccess, AggregatedUsage, Tier, KortexWorkflowMessage, KortexWorkflowPayload, KortexWorkflowResult, } from '../types/kortex';
+export type { TimberActor, TimberActorType, TimberChanges, TimberEntry, TimberLevel, TimberQueryParams, TimberQueryResponse, TimberSource, TimberUsage, TimberWritePayload, TimberLogPayload, } from '../types/timber';
 export { default as Component } from './component';
 export { default as Platform } from './platform';
 export { default as Functions } from './functions';
@@ -14,6 +16,7 @@ export { default as Sandbox } from './sandbox';
 export { default as System } from './system';
 export { default as Workflow } from './workflow';
 export { default as Forge } from './forge';
+export { default as Kortex } from './kortex';
 export { default as Project } from './project';
 export { default as Config } from './config';
 export { default as Integrations } from './integrations';
@@ -28,3 +31,4 @@ export { default as NBS } from './integrations/serbia/nbs';
 export { default as VPFR } from './integrations/serbia/minfin/vpfr';
 export { default as Mail } from './integrations/mail';
 export { default as Ecommerce } from './integrations/ecommerce';
+export { default as Timber } from './integrations/timber';

package/dist/v0.10/api/integrations/dms.d.ts

@@ -1,6 +1,6 @@
 import IntegrationsBaseClient from "../integrationsBaseClient";
 import { AxiosResponse } from "axios";
-import { PDFFillOptions, DataConversionParams, DataValidationParams, DataInfoParams, DataInfo, DataValidationResult, ConversionOptions, HTML2PDFOptions, PDF2HTMLOptions, MediaUploadPayload, MediaUploadBase64Payload, DocumentListParams, DocumentListResponse, DocumentCreatePayload, DocumentUpdatePayload, DocumentRestorePayload, DocumentCommentPayload, DocumentResponse, DocumentGeneratePayload, DocumentGenerateResponse } from "../../types/integrations";
+import { PDFFillOptions, DataConversionParams, DataValidationParams, DataInfoParams, DataInfo, DataValidationResult, ConversionOptions, HTML2PDFOptions, PDF2HTMLOptions, MediaUploadPayload, MediaUploadBase64Payload, DocumentListParams, DocumentListResponse, DocumentCreatePayload, DocumentUpdatePayload, DocumentRestorePayload, DocumentCommentPayload, DocumentResponse, DocumentGeneratePayload, DocumentGenerateResponse, DocumentRevisionListResponse } from "../../types/integrations";
 /**
  * Document Management System (DMS) API client
  *
@@ -143,6 +143,8 @@ export default class DMS extends IntegrationsBaseClient {
     restoreDocument(payload: DocumentRestorePayload): Promise<AxiosResponse<DocumentResponse>>;
     createDocumentComment(payload: DocumentCommentPayload): Promise<AxiosResponse<any, any>>;
     generateDocument(payload: DocumentGeneratePayload): Promise<AxiosResponse<DocumentGenerateResponse>>;
+    listDocumentRevisions(path: string): Promise<AxiosResponse<DocumentRevisionListResponse>>;
+    getDocumentRevision(path: string, version: string): Promise<AxiosResponse<DocumentResponse>>;
     fillPdf(data: PDFFillOptions): Promise<AxiosResponse<any, any>>;
     /**
      * Convert data between different formats (JSON, CSV, Excel)

package/dist/v0.10/api/integrations/timber.d.ts

@@ -0,0 +1,22 @@
+import IntegrationsBaseClient from "../integrationsBaseClient";
+import { TimberLogPayload, TimberQueryParams, TimberQueryResponse, TimberUsage, TimberWritePayload } from "../../types/timber";
+export default class Timber extends IntegrationsBaseClient {
+    query(params?: TimberQueryParams): Promise<TimberQueryResponse>;
+    write(payload: TimberWritePayload): Promise<{
+        accepted: boolean;
+    }>;
+    usage(): Promise<TimberUsage>;
+    debug(message: string, payload?: TimberLogPayload): Promise<{
+        accepted: boolean;
+    }>;
+    info(message: string, payload?: TimberLogPayload): Promise<{
+        accepted: boolean;
+    }>;
+    warn(message: string, payload?: TimberLogPayload): Promise<{
+        accepted: boolean;
+    }>;
+    error(message: string, payload?: TimberLogPayload): Promise<{
+        accepted: boolean;
+    }>;
+    private normalizeParams;
+}

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

@@ -7,6 +7,7 @@ import Payments from "./integrations/payments";
 import Minimax from "./integrations/minimax";
 import NBS from "./integrations/serbia/nbs";
 import Ecommerce from "./integrations/ecommerce";
+import Timber from "./integrations/timber";
 export default class Integrations extends IntegrationsBaseClient {
     private integrations;
     constructor(options?: {
@@ -22,6 +23,7 @@ export default class Integrations extends IntegrationsBaseClient {
     getNBS(): NBS;
     getSerbiaMinFin(): MinFin;
     getEcommerce(): Ecommerce;
+    getTimber(): Timber;
     list(): Promise<any>;
     isInstalled(id: string): Promise<boolean>;
     isActive(id: string): Promise<boolean>;

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

@@ -0,0 +1,52 @@
+import { AxiosResponse } from 'axios';
+import PlatformBaseClient from "./platformBaseClient";
+import { PagedResponse, PaginationParams, Agent, AgentCreatePayload, AgentUpdatePayload, KnowledgeBase, KnowledgeBaseCreatePayload, KnowledgeBaseUpdatePayload, Document, Conversation, ConversationCreatePayload, ConversationUpdatePayload, ParticipantAddPayload, Message, SendMessagePayload, InjectMessagePayload, OCRPayload, OCRResult, UserAccess, UserAccessCreatePayload, UserAccessUpdatePayload, UserMonthlyUsage, UserUsageBreakdown, MyAccess, AggregatedUsage, Tier } from '../types/kortex';
+export default class Kortex extends PlatformBaseClient {
+    createAgent(data: AgentCreatePayload): Promise<AxiosResponse<Agent>>;
+    listAgents(params?: PaginationParams): Promise<AxiosResponse<PagedResponse<Agent>>>;
+    getAgent(uuid: string): Promise<AxiosResponse<Agent>>;
+    updateAgent(uuid: string, data: AgentUpdatePayload): Promise<AxiosResponse<Agent>>;
+    deleteAgent(uuid: string): Promise<AxiosResponse<void>>;
+    listAgentKnowledgeBases(agentUUID: string): Promise<AxiosResponse<KnowledgeBase[]>>;
+    createKnowledgeBase(data: KnowledgeBaseCreatePayload): Promise<AxiosResponse<KnowledgeBase>>;
+    listKnowledgeBases(params?: PaginationParams): Promise<AxiosResponse<PagedResponse<KnowledgeBase>>>;
+    getKnowledgeBase(uuid: string): Promise<AxiosResponse<KnowledgeBase>>;
+    updateKnowledgeBase(uuid: string, data: KnowledgeBaseUpdatePayload): Promise<AxiosResponse<KnowledgeBase>>;
+    deleteKnowledgeBase(uuid: string): Promise<AxiosResponse<void>>;
+    listDocuments(kbUUID: string, params?: PaginationParams): Promise<AxiosResponse<PagedResponse<Document>>>;
+    uploadDocument(kbUUID: string, formData: FormData): Promise<AxiosResponse<Document>>;
+    getDocument(kbUUID: string, uuid: string): Promise<AxiosResponse<Document>>;
+    deleteDocument(kbUUID: string, uuid: string): Promise<AxiosResponse<void>>;
+    retryDocument(kbUUID: string, uuid: string): Promise<AxiosResponse<void>>;
+    createConversation(data: ConversationCreatePayload): Promise<AxiosResponse<Conversation>>;
+    listConversations(params?: PaginationParams & {
+        all_users?: boolean;
+        archived?: boolean;
+    }): Promise<AxiosResponse<PagedResponse<Conversation>>>;
+    getConversation(uuid: string): Promise<AxiosResponse<Conversation>>;
+    updateConversation(uuid: string, data: ConversationUpdatePayload): Promise<AxiosResponse<Conversation>>;
+    deleteConversation(uuid: string): Promise<AxiosResponse<void>>;
+    archiveConversation(uuid: string): Promise<AxiosResponse<void>>;
+    unarchiveConversation(uuid: string): Promise<AxiosResponse<void>>;
+    addParticipant(conversationUUID: string, data: ParticipantAddPayload): Promise<AxiosResponse<any>>;
+    removeParticipant(conversationUUID: string, agentUUID: string): Promise<AxiosResponse<void>>;
+    sendMessage(conversationUUID: string, data: SendMessagePayload): Promise<AxiosResponse<Message>>;
+    streamMessage(conversationUUID: string, data: SendMessagePayload): Promise<AxiosResponse<ReadableStream>>;
+    listMessages(conversationUUID: string, params?: PaginationParams): Promise<AxiosResponse<PagedResponse<Message>>>;
+    injectMessage(conversationUUID: string, data: InjectMessagePayload): Promise<AxiosResponse<Message>>;
+    ocr(data: OCRPayload): Promise<AxiosResponse<OCRResult>>;
+    createUserAccess(data: UserAccessCreatePayload): Promise<AxiosResponse<UserAccess>>;
+    listUserAccess(params?: PaginationParams): Promise<AxiosResponse<PagedResponse<UserAccess>>>;
+    getUserAccess(uuid: string): Promise<AxiosResponse<UserAccess>>;
+    updateUserAccess(uuid: string, data: UserAccessUpdatePayload): Promise<AxiosResponse<UserAccess>>;
+    deleteUserAccess(uuid: string): Promise<AxiosResponse<void>>;
+    getUserMonthlyUsage(uuid: string, params?: {
+        month?: string;
+    }): Promise<AxiosResponse<UserMonthlyUsage>>;
+    getUserUsageBreakdown(uuid: string): Promise<AxiosResponse<UserUsageBreakdown>>;
+    getMyAccess(): Promise<AxiosResponse<MyAccess>>;
+    listUsage(params?: PaginationParams & {
+        month?: string;
+    }): Promise<AxiosResponse<PagedResponse<AggregatedUsage>>>;
+    getTier(): Promise<AxiosResponse<Tier>>;
+}

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

@@ -11,6 +11,7 @@ import Sandbox from "./sandbox";
 import System from "./system";
 import Workflow from "./workflow";
 import Forge from "./forge";
+import Kortex from "./kortex";
 import Project from "./project";
 import Config from "./config";
 import PlatformBaseClient from "./platformBaseClient";
@@ -22,6 +23,7 @@ export default class Platform extends PlatformBaseClient {
     user(): Users;
     app(appType: string): Apps;
     forge(): Forge;
+    kortex(): Kortex;
     component<C extends string>(ref: C): Component<C>;
     componentUtils(): ComponentUtils;
     ratchet(): Ratchet;