@ptkl/sdk 0.10.2 → 1.0.1

package/dist/index.0.9.js

@@ -0,0 +1,2849 @@
+var ProtokolSDK09 = (function (exports, axios) {
+    'use strict';
+
+    class BaseClient {
+        constructor(client) {
+            this.client = client;
+        }
+        setClient(client) {
+            this.client = client;
+            return this;
+        }
+    }
+
+    const isNode = typeof process !== "undefined" &&
+        process.versions != null &&
+        process.versions.node != null;
+    const isBrowser = typeof window !== "undefined" &&
+        typeof document !== "undefined";
+    const isSandbox = typeof window !== "undefined";
+
+    /**
+     * Base client for the platform API
+     * Classes that extend PlatformBaseClient have intentins of only working in platform context
+     *
+     *
+     * @class PlatformBaseClient
+     * @extends BaseClient
+     * @constructor
+     * @param {AxiosInstance} [client] - The axios instance to use for the client
+     *
+     * @example
+     * // if sdk is used in the forge app that is running in the platform context
+     * const utils = new ComponentUtils()
+     * // this won't work outside of platform context because client needs authtorization to communicate with the API.
+     *
+     */
+    class PlatformBaseClient extends BaseClient {
+        constructor(options) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            let { env = null, token = null, host = null, } = options !== null && options !== void 0 ? options : {};
+            let headers = {};
+            var project_uuid = null;
+            if (isBrowser) {
+                if (sessionStorage.getItem('protokol_context') == "forge") {
+                    headers['X-Project-Env'] = (_a = sessionStorage.getItem('forge_app_env')) !== null && _a !== void 0 ? _a : "dev";
+                }
+                else {
+                    headers['X-Project-Env'] = (_b = localStorage.getItem('current_env')) !== null && _b !== void 0 ? _b : "dev";
+                }
+            }
+            else if (isNode) {
+                host = (_c = host !== null && host !== void 0 ? host : process.env.API_HOST) !== null && _c !== void 0 ? _c : null;
+                env = (_d = env !== null && env !== void 0 ? env : process.env.PROJECT_ENV) !== null && _d !== void 0 ? _d : null;
+                token = (_e = token !== null && token !== void 0 ? token : process.env.PROJECT_API_TOKEN) !== null && _e !== void 0 ? _e : null;
+                project_uuid = (_f = process.env.PROJECT_UUID) !== null && _f !== void 0 ? _f : null;
+            }
+            else if (isSandbox) {
+                // @ts-ignore
+                const __global_env__ = window === null || window === void 0 ? void 0 : window.__ENV_VARIABLES__;
+                host = (_g = __global_env__ === null || __global_env__ === void 0 ? void 0 : __global_env__.API_HOST) !== null && _g !== void 0 ? _g : host;
+                // @ts-ignore
+                env = env !== null && env !== void 0 ? env : __global_env__ === null || __global_env__ === void 0 ? void 0 : __global_env__.PROJECT_ENV;
+                token = token !== null && token !== void 0 ? token : __global_env__ === null || __global_env__ === void 0 ? void 0 : __global_env__.PROJECT_API_TOKEN;
+                project_uuid = __global_env__ === null || __global_env__ === void 0 ? void 0 : __global_env__.PROJECT_UUID;
+            }
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            if (env) {
+                headers['X-Project-Env'] = env;
+            }
+            if (project_uuid) {
+                headers['X-Project-Uuid'] = project_uuid;
+            }
+            const client = axios.create({
+                baseURL: host !== null && host !== void 0 ? host : "https://lemon.protokol.io",
+                timeout: 30000,
+                headers: {
+                    ...headers,
+                    'Content-Type': 'application/json',
+                },
+                withCredentials: true,
+            });
+            super(client);
+            this.env = null;
+            this.token = null;
+            this.host = null;
+        }
+    }
+
+    class Component extends PlatformBaseClient {
+        constructor(ref = null, options) {
+            var _a;
+            super();
+            this.ref = ref;
+            this.version = (_a = options === null || options === void 0 ? void 0 : options.version) !== null && _a !== void 0 ? _a : null;
+        }
+        /**
+         * Get the base path for component API calls
+         * @private
+         */
+        getComponentPath() {
+            if (this.version) {
+                return `/v3/system/component/${this.ref}/v/${this.version}`;
+            }
+            return `/v3/system/component/${this.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) {
+            const { cache = false, buildttl = -1, locale = "en_US", } = opts !== null && opts !== void 0 ? opts : {};
+            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.join(","),
+                limit: limit,
+                dateFrom: ctx.dateFrom,
+                dateTo: ctx.dateTo,
+                dateField: ctx.dateField,
+            };
+            if (Object.keys(ctx.$adv || []).length > 0) {
+                params.$adv = JSON.stringify([ctx.$adv]);
+            }
+            if (ctx.$aggregate && ctx.$aggregate.length > 0) {
+                params.$aggregate = JSON.stringify(ctx.$aggregate);
+            }
+            if (opts) {
+                Object.keys(opts).forEach(k => {
+                    if (['cache', 'buildttl', 'locale'].includes(k)) {
+                        return;
+                    }
+                    params[`_opt_${k}`] = opts ? opts[k] : null;
+                });
+            }
+            return await this.client.get(`${this.getComponentPath()}/models`, {
+                params: params,
+                headers: {
+                    'X-Cache': cache,
+                    'X-Build-Ttl': buildttl,
+                    'Accept-Language': locale
+                }
+            });
+        }
+        /**
+         * FindOne method to search for a single model
+         *
+         * @param {FindAdvancedParams} filter - The filters to apply to the search
+         * @param {FindOptions} opts - The options to apply to the search
+         *
+         * @returns {Promise<?Model>} - The result of the search
+         *
+         * @example
+         * platform.component(name).findOne({
+         *     name: "John Doe",
+         * })
+         **/
+        async findOne(filter, opts) {
+            const { data } = await this.find({
+                $adv: filter
+            }, opts);
+            const { items } = data || {};
+            if (items && items.length > 0) {
+                return items[0];
+            }
+            return null;
+        }
+        /**
+         * Get model by uuid
+         *
+         * @param uuid string - The uuid of the model
+         * @returns (Promise<Model>)
+         */
+        async get(uuid) {
+            return await this.client.get(`${this.getComponentPath()}/model/${uuid}`);
+        }
+        /**
+         * Update model by uuid
+         *
+         * @param uuid string - The uuid of the model
+         * @param data
+         * @returns
+         */
+        async update(uuid, data, options) {
+            return await this.client.post(`${this.getComponentPath()}/model/${uuid}`, {
+                data,
+                options,
+            });
+        }
+        /**
+         * Update many models
+         *
+         * @param data
+         * @param options
+         * @returns
+         */
+        async updateMany(data, options) {
+            return await this.client.patch(`${this.getComponentPath()}/models/bulk`, {
+                data,
+                options
+            });
+        }
+        /**
+         * Create many models
+         *
+         * @param data
+         * @param options
+         * @returns
+         */
+        async createMany(data, options) {
+            return await this.client.post(`${this.getComponentPath()}/models/bulk`, {
+                data,
+                options
+            });
+        }
+        /**
+         * Modify models by filters
+         *
+         * @param data
+         * @param options
+         * @returns
+         */
+        async modify(filters, data, options) {
+            return await this.client.patch(`${this.getComponentPath()}/modify/model`, {
+                filters,
+                data,
+                options,
+            });
+        }
+        /**
+         * Concurrent update model by uuid
+         *
+         * @param uuid string - The uuid of the model
+         * @param version number - The version of the model
+         * @param data
+         * @returns
+         */
+        async concurrentUpdate(uuid, version, data, options) {
+            return await this.client.post(`${this.getComponentPath()}/model/${uuid}`, {
+                version: version,
+                data,
+                options,
+            });
+        }
+        async create(model) {
+            return await this.client.post(`${this.getComponentPath()}/model`, model);
+        }
+        async delete(uuid) {
+            return await this.client.delete(`${this.getComponentPath()}/model/${uuid}`);
+        }
+        /**
+         * Execute aggregate pipeline with optional streaming support
+         *
+         * Returns a chainable object that allows both buffered and streaming modes.
+         * Call .onData() to enable streaming mode, or await directly for buffered mode.
+         *
+         * @param {FindAggregateParams} pipeline - MongoDB aggregation pipeline
+         *
+         * @returns {AggregateChainable} Chainable object with streaming methods and Promise interface
+         *
+         * @example
+         * ```typescript
+         * // Buffered response (default, up to 5K documents)
+         * const result = await component.aggregate([{ $match: { status: 'active' } }]);
+         * console.log(result.data); // All results at once
+         *
+         * // Streaming response (up to 25K documents)
+         * await component.aggregate([{ $match: { status: 'active' } }])
+         *   .onData((doc) => console.log('Received:', doc))
+         *   .onError((err) => console.error('Error:', err))
+         *   .onEnd(() => console.log('Stream complete'));
+         * ```
+         */
+        aggregate(pipeline) {
+            let onDataCallback = () => { };
+            let onErrorCallback;
+            let onEndCallback;
+            let isStreaming = false;
+            let streamPromise = null;
+            const chainable = {
+                onData: (callback) => {
+                    onDataCallback = callback;
+                    isStreaming = true;
+                    return chainable;
+                },
+                onError: (callback) => {
+                    onErrorCallback = callback;
+                    return chainable;
+                },
+                onEnd: (callback) => {
+                    onEndCallback = callback;
+                    return chainable;
+                },
+                then: (resolve, reject) => {
+                    if (isStreaming) {
+                        if (!streamPromise) {
+                            const handler = {
+                                onData: onDataCallback,
+                                onError: onErrorCallback,
+                                onEnd: onEndCallback
+                            };
+                            streamPromise = this._streamNDJSON(`${this.getComponentPath()}/aggregate`, {
+                                'Accept': 'application/x-ndjson',
+                                'Content-Type': 'application/json'
+                            }, handler, pipeline);
+                        }
+                        return streamPromise.then(resolve, reject);
+                    }
+                    return this.client.post(`${this.getComponentPath()}/aggregate`, pipeline)
+                        .then(resolve, reject);
+                },
+                catch: (reject) => {
+                    return chainable.then(undefined, reject);
+                }
+            };
+            return chainable;
+        }
+        async settings() {
+            return await this.client.get(`/v3/system/component/settings/${this.ref}`);
+        }
+        async saveSettings(settings, version) {
+            return await this.client.post(`/v3/system/component/settings/${this.ref}/${version}`, settings);
+        }
+        async saveTemplatesDist(version, sdkVersion, engine, dist) {
+            return await this.client.post(`/v3/system/component/templates/${this.ref}/${version}`, {
+                templates_dist: {
+                    sdk_version: sdkVersion,
+                    sdk_engine: engine,
+                    dist,
+                }
+            });
+        }
+        async workflow(event, input) {
+            return await this.client.post(`${this.getComponentPath()}/workflow/event`, {
+                event,
+                input
+            });
+        }
+        async function(name, input) {
+            return await this.client.post(`${this.getComponentPath()}/function/${name}`, {
+                data: input
+            });
+        }
+        async revisions(uuid) {
+            return await this.client.get(`${this.getComponentPath()}/model/${uuid}/revisions`);
+        }
+        /**
+         * Internal method to handle NDJSON streaming responses
+         *
+         * @private
+         */
+        async _streamNDJSON(url, headers, handler, body) {
+            try {
+                const config = {
+                    headers,
+                    responseType: 'stream'
+                };
+                const response = await this.client.post(url, body, config);
+                const stream = response.data;
+                let buffer = '';
+                return new Promise((resolve, reject) => {
+                    stream.on('data', (chunk) => {
+                        buffer += chunk.toString();
+                        // Process complete lines (separated by newlines)
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                        for (const line of lines) {
+                            if (line.trim()) {
+                                try {
+                                    const document = JSON.parse(line);
+                                    const result = handler.onData(document);
+                                    // Support async callbacks
+                                    if (result instanceof Promise) {
+                                        result.catch((err) => {
+                                            if (handler.onError) {
+                                                handler.onError(err);
+                                            }
+                                        });
+                                    }
+                                }
+                                catch (err) {
+                                    if (handler.onError) {
+                                        handler.onError(err);
+                                    }
+                                }
+                            }
+                        }
+                    });
+                    stream.on('end', () => {
+                        // Process any remaining data in buffer
+                        if (buffer.trim()) {
+                            try {
+                                const document = JSON.parse(buffer);
+                                handler.onData(document);
+                            }
+                            catch (err) {
+                                if (handler.onError) {
+                                    handler.onError(err);
+                                }
+                            }
+                        }
+                        if (handler.onEnd) {
+                            handler.onEnd();
+                        }
+                        resolve();
+                    });
+                    stream.on('error', (err) => {
+                        if (handler.onError) {
+                            handler.onError(err);
+                        }
+                        reject(err);
+                    });
+                });
+            }
+            catch (err) {
+                if (handler.onError) {
+                    handler.onError(err);
+                }
+                throw err;
+            }
+        }
+    }
+
+    class Functions extends PlatformBaseClient {
+        async list() {
+            return await this.client.get("/v1/system/function");
+        }
+        async get(ref) {
+            return await this.client.get(`/v1/system/function/${ref}`);
+        }
+        async update(uuid, update) {
+            return await this.client.patch(`/v1/system/function/${uuid}`, update);
+        }
+        /**
+         * Run platform function
+         *
+         * @param id - Function ID
+         * @param input - Input data
+         * @param query - Query parameters
+         * @returns - Function result
+         *
+         * @example
+         * const result = await platform.function().run("myFunction", {input: { foo: "bar" }})
+         */
+        async run(id, d) {
+            const { data } = await this.client.post(`/v1/system/function/run/${id}`, d.input, {
+                params: d.query,
+                headers: d.headers
+            });
+            return data;
+        }
+        async generateSignature(ref, env) {
+            return await this.client.get(`/v1/system/function/signature/${env}/${ref}`);
+        }
+    }
+
+    class APIUser extends PlatformBaseClient {
+        async auth(username, password, project) {
+            return this.client.post("/v1/user/api/auth", {
+                username,
+                password
+            }, {
+                headers: {
+                    "X-Project-Uuid": project
+                }
+            });
+        }
+        async newSecret(uuid) {
+            return await this.client.post(`/v1/user/api-user/secret/${uuid}`, {});
+        }
+        async revokeSecret(uuid) {
+            return await this.client.delete(`/v1/user/api-user/secret/${uuid}`);
+        }
+        async edit(uuid, roles) {
+            return await this.client.patch(`/v1/user/api-user/${uuid}`, { roles });
+        }
+        async list() {
+            return await this.client.get(`/v1/user/api-user`);
+        }
+        async get(uuid) {
+            return await this.client.get(`/v1/user/api-user/${uuid}`);
+        }
+    }
+
+    class Users extends PlatformBaseClient {
+        async auth(username, password, project) {
+            return await this.client.post("/v1/user/login", {
+                username,
+                password,
+                response_type: 'token',
+            }, {
+                headers: {
+                    'X-Project-Uuid': project
+                }
+            });
+        }
+        /**
+         * Resend confirmation email
+         * @param email User email
+         */
+        async resendConfirmationEmail(email) {
+            return await this.client.post("/v1/user/send/confirmation/email", {
+                email,
+            });
+        }
+        // Password Reset (Request Only)
+        // Note: Only the REQUEST is exposed, not the password reset completion
+        // The actual password reset should be done through the official web interface
+        /**
+         * Request password reset email
+         * This only sends an email with a reset link, does not expose or change passwords
+         * @param email User email
+         */
+        async requestPasswordReset(email) {
+            return await this.client.post("/v1/user/resetpassword", { email });
+        }
+        // User Profile & Management
+        /**
+         * Get current user's model
+         */
+        async getUser() {
+            return await this.client.get("/v1/user/model");
+        }
+        /**
+         * Get current user's claims
+         */
+        async getClaims() {
+            return await this.client.get("/v1/user/claims");
+        }
+        /**
+         * Edit user profile
+         * @param data Profile update data
+         */
+        async editProfile(data) {
+            return await this.client.post("/v1/user/profile/edit", data);
+        }
+        // Permissions & Roles
+        /**
+         * Get user permissions
+         */
+        async getPermissions() {
+            return await this.client.get("/v1/user/role/permissions");
+        }
+        /**
+         * Get list of available permissions
+         */
+        async listPermissions() {
+            return await this.client.get("/v1/user/permissions/list");
+        }
+        /**
+         * Create a new role
+         * @param role Role data including name, permissions, workspaces, and level
+         */
+        async createRole(role) {
+            return await this.client.post("/v1/user/role/create", role);
+        }
+        /**
+         * Delete a role
+         * @param uuid Role UUID
+         */
+        async deleteRole(uuid) {
+            return await this.client.delete(`/v1/user/role/delete/${uuid}`);
+        }
+        /**
+         * List all roles
+         */
+        async listRoles() {
+            return await this.client.get(`/v1/user/role/list`);
+        }
+        /**
+         * Get role details by UUID
+         * @param uuid Role UUID
+         */
+        async getRoleModel(uuid) {
+            return await this.client.get(`/v1/user/role/edit/${uuid}`);
+        }
+        /**
+         * Edit a role
+         * @param uuid Role UUID
+         * @param data Role update data including permissions, workspaces, and level
+         */
+        async editRole(uuid, data) {
+            return await this.client.post(`/v1/user/role/edit/${uuid}`, data);
+        }
+        /**
+         * @deprecated Use getPermissions() instead
+         */
+        async permissions() {
+            return await this.client.get(`/v1/user/role/permissions`);
+        }
+    }
+
+    class Apps extends PlatformBaseClient {
+        constructor(appType) {
+            super();
+            this.appType = appType;
+        }
+        async updateSettings(updateValues, ref) {
+            const payload = { ...updateValues };
+            return await this.client.put(`/v3/system/gateway/app-service/${this.appType}/${ref}/settings`, payload);
+        }
+        async download(ref, version) {
+            return await this.client.post(`/v3/system/gateway/app-service/${this.appType}/download`, { version, uuid: ref }, { responseType: "arraybuffer" });
+        }
+        async upload(formData) {
+            return await this.client.post(`/v3/system/gateway/app-service/${this.appType}/upload`, formData, {
+                timeout: 60000
+            });
+        }
+    }
+
+    class ComponentUtils extends PlatformBaseClient {
+        async list() {
+            return await this.client.get("/v1/system/components");
+        }
+        async create(data) {
+            return await this.client.post("/v3/system/component/create", data);
+        }
+    }
+
+    class Thunder extends PlatformBaseClient {
+        async read(type, filters, flag, options) {
+            return await this.client.post("/v3/system/thunder", {
+                type,
+                filters,
+                flag,
+                options,
+            });
+        }
+        async write(type, filters, d, flag) {
+            return await this.client.put("/v3/system/thunder", {
+                type,
+                filters,
+                flag,
+                data: d,
+            });
+        }
+        async operation(name, filters, data) {
+            return await this.write(name, filters, data, "Operation");
+        }
+        async find(name, filters) {
+            return await this.read(name, filters, "Find");
+        }
+        async findOne(name, filters) {
+            return await this.read(name, filters, "FindOne");
+        }
+        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");
+        }
+        async insertOne(name, data) {
+            return await this.write(name, {}, data, "InsertOne");
+        }
+        async updateOne(name, filters, data) {
+            return await this.write(name, filters, data, "UpdateOne");
+        }
+        async delete(name, filters) {
+            return await this.write(name, filters, {}, "Delete");
+        }
+    }
+
+    class Ratchet extends PlatformBaseClient {
+        /**
+         * Get all database connections for the current project
+         *
+         * @returns List of all configured ratchet connections
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         * const connections = await ratchet.getConnections();
+         * console.log(connections.data); // Array of connections
+         * ```
+         */
+        async getConnections() {
+            return await this.client.get("/v1/ratchet/connection");
+        }
+        /**
+         * Get a specific database connection by ID
+         *
+         * @param id - Connection ID
+         * @returns Connection details including queries
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         * const connection = await ratchet.getConnection('users_db');
+         * console.log(connection.data.queries); // Available queries for this connection
+         * ```
+         */
+        async getConnection(id) {
+            return await this.client.get(`/v1/ratchet/connection/${id}`);
+        }
+        /**
+         * Create a new database connection
+         *
+         * Supports multiple database types:
+         * - MySQL: Use credentials with host, dbname, user, password
+         * - PostgreSQL: Use credentials with host, dbname, user, password
+         * - MongoDB: Use DSN connection string
+         * - BigQuery: Use service_account_json and project_id
+         *
+         * @param connection - Connection configuration
+         * @returns Created connection details
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         *
+         * // MySQL/PostgreSQL connection
+         * await ratchet.createConnection({
+         *   id: 'users_db',
+         *   type: 'MySQL',
+         *   credentials: {
+         *     type: 'Credentials',
+         *     host: 'localhost',
+         *     dbname: 'users',
+         *     user: 'admin',
+         *     password: 'secret'
+         *   }
+         * });
+         *
+         * // MongoDB connection
+         * await ratchet.createConnection({
+         *   id: 'mongo_db',
+         *   type: 'MongoDB',
+         *   credentials: {
+         *     type: 'DSN',
+         *     dsn: 'mongodb://localhost:27017/mydb'
+         *   }
+         * });
+         *
+         * // BigQuery connection
+         * await ratchet.createConnection({
+         *   id: 'analytics_bq',
+         *   type: 'BigQuery',
+         *   credentials: {
+         *     type: 'ServiceAccount',
+         *     service_account_json: '{"type":"service_account",...}',
+         *     project_id: 'my-project-id'
+         *   }
+         * });
+         * ```
+         */
+        async createConnection(connection) {
+            return await this.client.post("/v1/ratchet/connection", connection);
+        }
+        /**
+         * Update an existing database connection
+         *
+         * @param connection - Updated connection configuration
+         * @returns Success status
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         * await ratchet.updateConnection({
+         *   id: 'users_db',
+         *   type: 'postgres',
+         *   credentials: {
+         *     type: 'postgres',
+         *     host: 'localhost',
+         *     dbname: 'users',
+         *     user: 'admin',
+         *     password: 'new_secret'
+         *   },
+         *   queries: [
+         *     { id: 'get_user', expression: 'SELECT * FROM users WHERE id = $1' }
+         *   ]
+         * });
+         * ```
+         */
+        async updateConnection(connection) {
+            return await this.client.put("/v1/ratchet/connection", connection);
+        }
+        /**
+         * Delete a database connection
+         *
+         * @param id - Connection ID to delete
+         * @returns Success status
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         * await ratchet.deleteConnection('users_db');
+         * ```
+         */
+        async deleteConnection(id) {
+            return await this.client.delete(`/v1/ratchet/connection/${id}`);
+        }
+        /**
+         * Test a database connection without saving it
+         *
+         * @param connection - Connection configuration to test
+         * @returns Success status if connection is valid
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         * const isValid = await ratchet.testConnection({
+         *   id: 'test_db',
+         *   type: 'postgres',
+         *   credentials: {
+         *     type: 'postgres',
+         *     host: 'localhost',
+         *     dbname: 'test',
+         *     user: 'admin',
+         *     password: 'secret'
+         *   }
+         * });
+         * ```
+         */
+        async testConnection(connection) {
+            return await this.client.post("/v1/ratchet/test/connection", connection);
+        }
+        /**
+         * Execute a predefined database query
+         *
+         * Runs a query that has been previously configured in a ratchet connection.
+         * The query is identified by a qualified name in the format: `connectionId.queryId`
+         *
+         * @param name - Qualified name of the query (format: `connectionId.queryId`)
+         * @param params - Array of parameters to pass to the query
+         * @returns Query execution results
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         *
+         * // Execute a query with parameters
+         * const result = await ratchet.query('users_db.get_user_by_id', [123]);
+         *
+         * // Execute a query without parameters
+         * const allUsers = await ratchet.query('users_db.get_all_users', []);
+         * ```
+         */
+        async query(name, params) {
+            return await this.client.post("/v1/ratchet/query", {
+                name: name,
+                params: params,
+            });
+        }
+        /**
+         * Inspect and execute a custom query without saving it
+         *
+         * This allows you to test queries before saving them to a connection.
+         *
+         * @param request - Query inspection request with connection name, query, and params
+         * @returns Query execution results
+         *
+         * @example
+         * ```typescript
+         * const ratchet = new Ratchet();
+         * const result = await ratchet.inspectQuery({
+         *   name: 'users_db.test_query',
+         *   query: {
+         *     id: 'test_query',
+         *     expression: 'SELECT * FROM users WHERE email = $1'
+         *   },
+         *   params: ['user@example.com']
+         * });
+         * ```
+         */
+        async inspectQuery(request) {
+            return await this.client.post("/v1/ratchet/query/inspect", request);
+        }
+    }
+
+    class Sandbox extends PlatformBaseClient {
+        /**
+         * Call the sandbox service to execute a serverless function
+         *
+         * @param name
+         * @param data
+         * @returns
+         *
+         * @example
+         * const result = await platform.sandbox().spark("myFunction", { foo: "bar" })
+         */
+        async spark(name, data) {
+            return await this.client.post(`/v1/project/sandbox/spark/exec/${name}`, data);
+        }
+    }
+
+    class System extends PlatformBaseClient {
+        async resourceResolver(ref, resourceName, format) {
+            return await this.client.post("/v3/system/resource-resolver", {
+                type: resourceName,
+                ref,
+                format,
+            });
+        }
+    }
+
+    class Workflow extends PlatformBaseClient {
+        async trigger(id, event, data) {
+            return await this.client.post(`/v1/project/workflow/workflow/${id}/event/${event}`, data);
+        }
+        async publish(event, data) {
+            return await this.client.post(`/v1/project/workflow/workflow/event/${event}`, data);
+        }
+    }
+
+    class Forge extends PlatformBaseClient {
+        async bundleUpload(buffer) {
+            return await this.client.post(`/luma/appservice/v1/forge/upload`, buffer, {
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    'Content-Length': buffer.length
+                }
+            });
+        }
+        async getWorkspaceApps() {
+            return await this.client.get(`/luma/appservice/v1/forge/workspace`);
+        }
+        async removeVersion(ref, version) {
+            return await this.client.delete(`/luma/appservice/v1/forge/${ref}/version/${version}`);
+        }
+        async list() {
+            return await this.client.get(`/luma/appservice/v1/forge`);
+        }
+    }
+
+    class Project extends PlatformBaseClient {
+        /**
+         * Get list of all projects for the current user
+         */
+        async list() {
+            return await this.client.get("/v1/project/list");
+        }
+        /**
+         * Create a new project
+         * @param data Project creation data
+         */
+        async create(data) {
+            return await this.client.post("/v1/project/create", data);
+        }
+        /**
+         * Get information about a specific project
+         */
+        async info() {
+            return await this.client.get("/v1/project/info");
+        }
+        /**
+         * Archive a project
+         */
+        async archive() {
+            return await this.client.patch("/v1/project/archive");
+        }
+        /**
+         * Invite a user to the project
+         * @param email Array of emails
+         * @param roles Array of role UUIDs
+         */
+        async invite(emails, roles) {
+            return await this.client.post("/v1/project/invite", { emails: emails.join(","), roles });
+        }
+        /**
+         * Get list of project invites
+         */
+        async getInvites() {
+            return await this.client.get("/v1/project/invites");
+        }
+        /**
+         * Get a specific invite by UUID
+         * @param uuid Invite UUID
+         */
+        async getInvite(uuid) {
+            return await this.client.get(`/v1/project/invite/${uuid}`);
+        }
+        /**
+         * Accept an invite
+         * @param uuid Invite UUID
+         */
+        async acceptInvite(uuid) {
+            return await this.client.get(`/v1/project/invite/accept/${uuid}`);
+        }
+        /**
+         * Register through an invite
+         * @param uuid Invite UUID
+         * @param data Registration data
+         */
+        async registerWithInvite(uuid, data) {
+            return await this.client.post(`/v1/project/invite/register/${uuid}`, data);
+        }
+        /**
+         * Get list of project users
+         */
+        async getUsers() {
+            return await this.client.get("/v1/project/users");
+        }
+        /**
+         * Get a specific project user
+         * @param uuid User UUID
+         */
+        async getUser(uuid) {
+            return await this.client.get(`/v1/project/user/${uuid}`);
+        }
+        /**
+         * Update a project user
+         * @param uuid User UUID
+         * @param data Update data
+         */
+        async updateUser(uuid, data) {
+            return await this.client.put(`/v1/project/user/${uuid}`, data);
+        }
+        /**
+         * Delete a user from the project
+         * @param uuid User UUID
+         */
+        async deleteUser(uuid) {
+            return await this.client.delete(`/v1/project/user/${uuid}`);
+        }
+        /**
+         * Update project settings
+         * @param settings Settings data
+         */
+        async updateSettings(settings) {
+            return await this.client.post("/v1/project/settings", settings);
+        }
+        // Workspace Methods
+        /**
+         * Create a new workspace
+         * @param data Workspace data
+         */
+        async createWorkspace(data) {
+            return await this.client.post("/v1/project/workspace", data);
+        }
+        /**
+         * Update a workspace
+         * @param uuid Workspace UUID
+         * @param data Update data
+         */
+        async updateWorkspace(uuid, data) {
+            return await this.client.put(`/v1/project/workspace/${uuid}`, data);
+        }
+        /**
+         * Delete a workspace
+         * @param uuid Workspace UUID
+         */
+        async deleteWorkspace(uuid) {
+            return await this.client.delete(`/v1/project/workspace/${uuid}`);
+        }
+        // Template Methods
+        /**
+         * Get available templates
+         */
+        async getAvailableTemplates() {
+            return await this.client.get("/v1/project/template/available");
+        }
+        /**
+         * Search for templates
+         * @param query Search query
+         */
+        async searchTemplates(query) {
+            return await this.client.post("/v1/project/template/search", query);
+        }
+        /**
+         * Get template by ID
+         * @param id Template ID
+         */
+        async getTemplate(id) {
+            return await this.client.get(`/v1/project/template/${id}`);
+        }
+        /**
+         * Get template by activation code
+         * @param code Activation code
+         */
+        async getTemplateByCode(code) {
+            return await this.client.get(`/v1/project/template/activationCode/${code}`);
+        }
+        /**
+         * Get templates for a workspace
+         */
+        async getWorkspaceTemplates() {
+            return await this.client.get("/v1/project/template/workspace");
+        }
+        /**
+         * Install a template
+         * @param data Installation data
+         */
+        async installTemplate(data) {
+            return await this.client.post("/v1/project/template/install", data);
+        }
+        /**
+         * Uninstall a template
+         * @param data Uninstallation data
+         */
+        async uninstallTemplate(data) {
+            return await this.client.post("/v1/project/template/uninstall", data);
+        }
+        /**
+         * Upgrade a template
+         * @param data Upgrade data
+         */
+        async upgradeTemplate(data) {
+            return await this.client.post("/v1/project/template/upgrade", data);
+        }
+    }
+
+    class Config extends PlatformBaseClient {
+        /**
+         * Get user configuration
+         */
+        async getUserConfig() {
+            return await this.client.get("/v1/config/user");
+        }
+        /**
+         * Update user configuration
+         * @param config Configuration data
+         */
+        async updateUserConfig(config) {
+            return await this.client.put("/v1/config/user", config);
+        }
+    }
+
+    // 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);
+        }
+        component(ref, options) {
+            return (new Component(ref, options)).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 Invoicing extends PlatformBaseClient {
+        async getSalesInvoices(provider, page) {
+            return await this.request("GET", `invoices/${provider}/sales`, {
+                params: {
+                    page: page || 1
+                }
+            });
+        }
+        async acceptPurchaseInvoice(provider, id, comment) {
+            return await this.request('POST', `invoices/${provider}/purchase/acceptReject/${id}`, {
+                data: {
+                    accepted: true,
+                    comment: comment
+                }
+            });
+        }
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/karadjordje/v1/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class IntegrationsBaseClient extends BaseClient {
+        constructor(options) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            let { env = null, token = null, host = null, } = options !== null && options !== void 0 ? options : {};
+            let headers = {};
+            var project_uuid = null;
+            if (isBrowser) {
+                if (sessionStorage.getItem('protokol_context') == "forge") {
+                    headers['X-Project-Env'] = (_a = sessionStorage.getItem('forge_app_env')) !== null && _a !== void 0 ? _a : "dev";
+                }
+                else {
+                    headers['X-Project-Env'] = (_b = localStorage.getItem('current_env')) !== null && _b !== void 0 ? _b : "dev";
+                }
+            }
+            else if (isNode) {
+                host = (_c = host !== null && host !== void 0 ? host : process.env.INTEGRATION_API) !== null && _c !== void 0 ? _c : null;
+                env = (_d = env !== null && env !== void 0 ? env : process.env.PROJECT_ENV) !== null && _d !== void 0 ? _d : null;
+                token = (_e = token !== null && token !== void 0 ? token : process.env.PROJECT_API_TOKEN) !== null && _e !== void 0 ? _e : null;
+                project_uuid = (_f = process.env.PROJECT_UUID) !== null && _f !== void 0 ? _f : null;
+            }
+            else if (isSandbox) {
+                // @ts-ignore
+                const __global_env__ = window === null || window === void 0 ? void 0 : window.__ENV_VARIABLES__;
+                host = (_g = __global_env__ === null || __global_env__ === void 0 ? void 0 : __global_env__.INTEGRATION_API) !== null && _g !== void 0 ? _g : host;
+                // @ts-ignore
+                env = env !== null && env !== void 0 ? env : __global_env__ === null || __global_env__ === void 0 ? void 0 : __global_env__.PROJECT_ENV;
+                token = token !== null && token !== void 0 ? token : __global_env__ === null || __global_env__ === void 0 ? void 0 : __global_env__.PROJECT_API_TOKEN;
+            }
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            if (env) {
+                headers['X-Project-Env'] = env;
+            }
+            if (project_uuid) {
+                headers['X-Project-Uuid'] = project_uuid;
+            }
+            const client = axios.create({
+                baseURL: host !== null && host !== void 0 ? host : "https://lemon.protokol.io/luma/integrations",
+                timeout: 30000,
+                headers: {
+                    ...headers,
+                },
+                withCredentials: true,
+            });
+            super(client);
+            this.env = null;
+            this.token = null;
+            this.host = null;
+        }
+    }
+
+    /**
+     * Document Management System (DMS) API client
+     *
+     * Provides comprehensive document and media management capabilities including:
+     * - File upload, download, and management
+     * - PDF generation and form filling
+     * - Data conversion between JSON, CSV, and Excel formats
+     * - Media processing and EXIF data extraction
+     *
+     * ## Data Conversion Features
+     *
+     * The DMS class includes powerful data conversion capabilities that allow you to:
+     * - Convert between JSON, CSV, and Excel (.xlsx) formats
+     * - Handle structured data with header, items, and footer sections
+     * - Auto-detect structured patterns in JSON arrays
+     * - Validate data format integrity
+     * - Analyze data structure and metadata
+     * - Handle large datasets with memory-efficient processing
+     *
+     * ### Supported Formats
+     * - **JSON**: Array of objects (recommended for tabular data) or structured objects
+     * - **CSV**: Comma-separated values with headers and optional comments
+     * - **Excel**: .xlsx format with optional sheet specification
+     *
+     * ### Structured Data Support
+     * When converting from JSON, the API supports:
+     *
+     * **Explicit Structure**: JSON with dedicated sections
+     * ```json
+     * {
+     *   "header": { "content": { "title": "Report" } },
+     *   "items": [{ "name": "Data" }],
+     *   "footer": { "content": { "total": 100 } }
+     * }
+     * ```
+     *
+     * **Auto-Detection**: Mixed arrays with metadata and summary objects
+     * ```json
+     * [
+     *   { "metadata": "Header info" },
+     *   { "name": "John", "age": 30 },
+     *   { "summary": "Footer info" }
+     * ]
+     * ```
+     *
+     * ### Error Handling
+     * All conversion methods may throw errors with code 3003 for conversion failures.
+     * Always wrap calls in try-catch blocks for production use.
+     *
+     * @example
+     * ```typescript
+     * import { DMS } from 'protokol-sdk';
+     *
+     * const dms = new DMS({
+     *   token: 'your-bearer-token',
+     *   host: 'http://localhost:8086'
+     * });
+     *
+     * const libraryRef = 'your-library-uuid';
+     *
+     * // Convert structured JSON to CSV with comments
+     * const structuredData = {
+     *   header: { content: { title: "Sales Report" } },
+     *   items: [{ product: "Widget", sales: 100 }],
+     *   footer: { content: { total: 100 } }
+     * };
+     *
+     * try {
+     *   const csvResult = await dms.convertData(libraryRef, structuredData, {
+     *     from: 'json',
+     *     to: 'csv',
+     *     header_as_comment: true
+     *   });
+     *   console.log(csvResult.data); // CSV with header as comments
+     * } catch (error) {
+     *   console.error('Conversion failed:', error.message);
+     * }
+     * ```
+     */
+    class DMS extends IntegrationsBaseClient {
+        async list(data) {
+            return this.request('POST', 'media/list', { data });
+        }
+        async libraries() {
+            return await this.requestv1("GET", "media/library/list");
+        }
+        async upload(payload) {
+            let files = payload.files;
+            let formData = new FormData();
+            let count = 0;
+            files.forEach((file, index) => {
+                let rename = file.rename || file.name;
+                let orgExt = file.name.split('.');
+                rename = `${rename}.${orgExt[orgExt.length - 1]}`;
+                formData.append('file', file, rename);
+                count++;
+            });
+            if (count == files.length) {
+                formData.append('path', payload.uploadDir);
+                formData.append('ref', payload.uuid);
+                if (payload.public) {
+                    formData.append('is_public', "true");
+                }
+                if (payload.expiresAt)
+                    formData.append('expiresAt', new Date(payload.expiresAt).toISOString());
+                if (Object.keys(payload.metadata).length > 0)
+                    formData.append('metadata', JSON.stringify(payload.metadata));
+                return await this.request("POST", "media/upload", {
+                    data: formData,
+                    headers: {
+                        'Content-Type': 'multipart/form-data'
+                    }
+                });
+            }
+        }
+        async delete(data) {
+            return this.request('POST', 'media/delete', data);
+        }
+        async uploadBase64(data) {
+            return this.request('POST', `media/upload`, {
+                data,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        async getMedia(lib, key, encoding) {
+            return this.request('GET', `media/library/${lib}/get/${key}`, {
+                params: {
+                    encoding
+                },
+                responseType: (!encoding) ? 'blob' : null
+            });
+        }
+        async download(lib, key) {
+            return this.request('POST', `media/library/${lib}/download`, {
+                data: {
+                    key
+                },
+                responseType: 'blob'
+            });
+        }
+        async getExifData(lib, key) {
+            return this.request('GET', `media/library/${lib}/exif/${key}`);
+        }
+        async html2pdf(lib, data) {
+            const { output_pdf = false, input_path, input_html, output_path, output_file_name, output_type, data: templateData } = data;
+            const type = output_pdf ? 'arraybuffer' : 'json';
+            const contentType = output_pdf ? 'application/pdf' : 'application/json';
+            return this.request('POST', `media/library/${lib}/html2pdf`, {
+                data: {
+                    output_pdf,
+                    input_path,
+                    output_path,
+                    input_html,
+                    output_file_name,
+                    output_type,
+                    data: templateData
+                },
+                headers: {
+                    'Content-Type': contentType
+                },
+                responseType: type
+            });
+        }
+        async createDir(lib, path) {
+            return this.request('POST', `media/library/${lib}/dir`, { data: { path } });
+        }
+        async deleteDir(lib, path) {
+            return this.request('POST', `media/library/${lib}/delete/dir`, { data: { path } });
+        }
+        async dirs(lib, data) {
+            return await this.request("POST", `media/library/${lib}/dirs`, { data });
+        }
+        async fillPdf(lib, data) {
+            const { input_path, output_path, output_pdf = false, output_type, output_file_name, form_data, forms } = data;
+            const responseType = output_pdf ? 'arraybuffer' : 'json';
+            const contentType = output_pdf ? 'application/pdf' : 'application/json';
+            return this.request('POST', `media/library/${lib}/pdf/fill`, {
+                data: {
+                    input_path,
+                    output_path,
+                    output_pdf,
+                    output_type,
+                    output_file_name,
+                    form_data,
+                    forms
+                },
+                headers: {
+                    'Content-Type': contentType
+                },
+                responseType
+            });
+        }
+        // ===================================================================
+        // Data Converter Methods
+        // ===================================================================
+        // 
+        // The following methods provide comprehensive data conversion capabilities
+        // between JSON, CSV, and Excel formats, along with validation and analysis tools.
+        // All methods require a valid library reference UUID and return AxiosResponse objects.
+        //
+        /**
+         * Convert data between different formats (JSON, CSV, Excel)
+         *
+         * Supports structured data when converting from JSON format with:
+         * - Explicit structure: JSON with `header`, `items`, and `footer` properties
+         * - Auto-detection: Mixed JSON arrays with metadata objects and summary rows
+         *
+         * @param lib - Library reference UUID
+         * @param data - Raw data to convert
+         * @param params - Conversion parameters including structured data options
+         * @returns Promise resolving to converted data
+         *
+         * @example
+         * ```typescript
+         * // Convert JSON to CSV
+         * const jsonData = [
+         *   { name: "John Doe", age: 30, email: "john@example.com" },
+         *   { name: "Jane Smith", age: 25, email: "jane@example.com" }
+         * ];
+         *
+         * const csvResult = await dms.convertData(libraryRef, jsonData, {
+         *   from: 'json',
+         *   to: 'csv'
+         * });
+         * console.log(csvResult.data); // CSV string
+         *
+         * // Convert structured JSON with header as comments
+         * const structuredData = {
+         *   header: {
+         *     content: {
+         *       report_title: "Monthly Sales Report",
+         *       generated_by: "Sales System"
+         *     }
+         *   },
+         *   items: [
+         *     { product: "Widget A", sales: 100 },
+         *     { product: "Widget B", sales: 150 }
+         *   ],
+         *   footer: {
+         *     content: {
+         *       total_sales: 250
+         *     }
+         *   }
+         * };
+         *
+         * const csvWithComments = await dms.convertData(libraryRef, structuredData, {
+         *   from: 'json',
+         *   to: 'csv',
+         *   header_as_comment: true,
+         *   separator_rows: 2
+         * });
+         *
+         * // Convert JSON to Excel with custom sheet name
+         * const excelResult = await dms.convertData(libraryRef, jsonData, {
+         *   from: 'json',
+         *   to: 'excel',
+         *   sheet_name: 'Customer Data'
+         * });
+         * // excelResult.data is a Blob
+         * ```
+         */
+        async convertData(lib, data, params) {
+            const { from, to, sheet_name, include_header, include_footer, header_as_comment, footer_as_comment, separator_rows, field_order, } = params;
+            const queryParams = { from, to };
+            // Add optional parameters if provided
+            if (sheet_name)
+                queryParams.sheet_name = sheet_name;
+            if (include_header !== undefined)
+                queryParams.include_header = include_header;
+            if (include_footer !== undefined)
+                queryParams.include_footer = include_footer;
+            if (header_as_comment !== undefined)
+                queryParams.header_as_comment = header_as_comment;
+            if (footer_as_comment !== undefined)
+                queryParams.footer_as_comment = footer_as_comment;
+            if (separator_rows !== undefined)
+                queryParams.separator_rows = separator_rows;
+            if (field_order !== undefined)
+                queryParams.field_order = field_order.join(',');
+            console.log('Conversion Query Params:', queryParams);
+            // Determine content type based on target format
+            let responseType = 'text';
+            if (to === 'json') {
+                responseType = 'json';
+            }
+            else if (to === 'excel' || to === 'xlsx') {
+                responseType = 'blob';
+            }
+            return this.request('POST', `media/library/${lib}/convert/data`, {
+                data,
+                params: queryParams,
+                responseType,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        /**
+         * Get information about data format and structure
+         *
+         * @param lib - Library reference UUID
+         * @param data - Raw data to analyze
+         * @param params - Analysis parameters
+         * @returns Promise resolving to data information
+         *
+         * @example
+         * ```typescript
+         * const jsonData = [
+         *   { name: "John", age: 30, email: "john@example.com" },
+         *   { name: "Jane", age: 25, email: "jane@example.com" }
+         * ];
+         *
+         * const dataInfo = await dms.getDataInfo(libraryRef, jsonData, {
+         *   format: 'json'
+         * });
+         *
+         * console.log(dataInfo.data);
+         * // Output:
+         * // {
+         * //   format: "json",
+         * //   size_bytes: 245,
+         * //   record_count: 2,
+         * //   field_count: 3,
+         * //   fields: ["name", "age", "email"],
+         * //   library_ref: "98bee1cb-0f21-4582-a832-7c32b4b61831"
+         * // }
+         * ```
+         */
+        async getDataInfo(lib, data, params) {
+            const { format } = params;
+            return this.request('POST', `media/library/${lib}/convert/info`, {
+                data,
+                params: { format },
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        /**
+         * Validate data format without performing conversion
+         *
+         * @param lib - Library reference UUID
+         * @param data - Raw data to validate
+         * @param params - Validation parameters
+         * @returns Promise resolving to validation result
+         *
+         * @example
+         * ```typescript
+         * const jsonData = [{ name: "John", age: 30 }];
+         *
+         * const validation = await dms.validateData(libraryRef, jsonData, {
+         *   format: 'json'
+         * });
+         *
+         * console.log(validation.data);
+         * // Output:
+         * // {
+         * //   valid: true,
+         * //   message: "Data is valid JSON format",
+         * //   library_ref: "98bee1cb-0f21-4582-a832-7c32b4b61831"
+         * // }
+         *
+         * // Handle invalid data
+         * try {
+         *   const invalidValidation = await dms.validateData(libraryRef, "invalid json", {
+         *     format: 'json'
+         *   });
+         * } catch (error) {
+         *   console.error('Validation failed:', error.response?.data?.message);
+         * }
+         * ```
+         */
+        async validateData(lib, data, params) {
+            const { format } = params;
+            return this.request('POST', `media/library/${lib}/convert/validate`, {
+                data,
+                params: { format },
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        /**
+         * Convert JSON data to CSV format
+         *
+         * This method supports both regular JSON arrays and structured data with auto-detection:
+         * - Regular arrays are converted directly to CSV
+         * - Structured data (with metadata objects) is automatically detected and formatted
+         *
+         * @param lib - Library reference UUID
+         * @param jsonData - JSON data (array of objects or structured data)
+         * @returns Promise resolving to CSV string
+         *
+         * @example
+         * ```typescript
+         * // Regular JSON to CSV
+         * const jsonData = [
+         *   { name: "John Doe", age: 30, email: "john@example.com" },
+         *   { name: "Jane Smith", age: 25, email: "jane@example.com" }
+         * ];
+         *
+         * const csvResponse = await dms.jsonToCsv(libraryRef, jsonData);
+         * console.log(csvResponse.data);
+         * // Output:
+         * // name,age,email
+         * // John Doe,30,john@example.com
+         * // Jane Smith,25,jane@example.com
+         *
+         * // Structured JSON with auto-detection
+         * const structuredData = [
+         *   { metadata: "EMPLOYEE REPORT\nGenerated: 2025-10-08" },
+         *   { name: "John Doe", age: 30, position: "Developer" },
+         *   { name: "Jane Smith", age: 25, position: "Designer" },
+         *   { name: "Total Employees:", age: null, position: "2 people" }
+         * ];
+         *
+         * const structuredCsv = await dms.jsonToCsv(libraryRef, structuredData);
+         * // Auto-detects header, items, and footer sections
+         * ```
+         */
+        async jsonToCsv(lib, jsonData, options) {
+            let params = {};
+            if (options === null || options === void 0 ? void 0 : options.field_order) {
+                params.field_order = options.field_order.join(',');
+            }
+            return this.request('POST', `media/library/${lib}/convert/json-to-csv`, {
+                params,
+                data: jsonData,
+                responseType: 'text',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        /**
+         * Convert JSON data to Excel (.xlsx) format
+         *
+         * Supports both regular JSON arrays and structured data patterns.
+         * Excel files are always generated with .xlsx extension.
+         *
+         * @param lib - Library reference UUID
+         * @param jsonData - JSON data (array of objects or structured data)
+         * @param options - Optional conversion options
+         * @returns Promise resolving to Excel file as Blob
+         *
+         * @example
+         * ```typescript
+         * // Regular JSON to Excel
+         * const jsonData = [
+         *   { name: "John Doe", age: 30, email: "john@example.com" },
+         *   { name: "Jane Smith", age: 25, email: "jane@example.com" }
+         * ];
+         *
+         * // Basic conversion
+         * const excelResponse = await dms.jsonToExcel(libraryRef, jsonData);
+         * const blob = excelResponse.data; // Blob for download
+         *
+         * // With custom sheet name
+         * const excelWithOptions = await dms.jsonToExcel(libraryRef, jsonData, {
+         *   sheet_name: 'Customer Data'
+         * });
+         *
+         * // Structured data with explicit sections
+         * const structuredData = {
+         *   header: { content: { title: "Monthly Report" } },
+         *   items: [{ product: "Widget A", sales: 100 }],
+         *   footer: { content: { total_sales: 100 } }
+         * };
+         *
+         * const structuredExcel = await dms.jsonToExcel(libraryRef, structuredData);
+         *
+         * // Create download link
+         * const url = URL.createObjectURL(structuredExcel.data);
+         * const link = document.createElement('a');
+         * link.href = url;
+         * link.download = 'report.xlsx'; // Always .xlsx extension
+         * link.click();
+         * ```
+         */
+        async jsonToExcel(lib, jsonData, options) {
+            const params = {};
+            if (options === null || options === void 0 ? void 0 : options.sheet_name) {
+                params.sheet_name = options.sheet_name;
+            }
+            if (options === null || options === void 0 ? void 0 : options.field_order) {
+                params.field_order = options.field_order.join(',');
+            }
+            return this.request('POST', `media/library/${lib}/convert/json-to-excel`, {
+                data: jsonData,
+                params,
+                responseType: 'blob',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        /**
+         * Convert CSV data to JSON format
+         *
+         * @param lib - Library reference UUID
+         * @param csvData - CSV data string (with headers in first row)
+         * @returns Promise resolving to JSON array
+         *
+         * @example
+         * ```typescript
+         * const csvString = `name,age,email
+         * John Doe,30,john@example.com
+         * Jane Smith,25,jane@example.com`;
+         *
+         * const jsonResponse = await dms.csvToJson(libraryRef, csvString);
+         * console.log(jsonResponse.data);
+         * // Output:
+         * // [
+         * //   { name: "John Doe", age: "30", email: "john@example.com" },
+         * //   { name: "Jane Smith", age: "25", email: "jane@example.com" }
+         * // ]
+         * ```
+         */
+        async csvToJson(lib, csvData) {
+            return this.request('POST', `media/library/${lib}/convert/csv-to-json`, {
+                data: csvData,
+                responseType: 'json',
+                headers: {
+                    'Content-Type': 'text/csv'
+                }
+            });
+        }
+        /**
+         * Convert CSV data to Excel (.xlsx) format
+         *
+         * @param lib - Library reference UUID
+         * @param csvData - CSV data string (with headers in first row)
+         * @param options - Optional conversion options
+         * @returns Promise resolving to Excel file as Blob
+         *
+         * @example
+         * ```typescript
+         * const csvString = `name,age,email
+         * John Doe,30,john@example.com
+         * Jane Smith,25,jane@example.com`;
+         *
+         * const excelResponse = await dms.csvToExcel(libraryRef, csvString, {
+         *   sheet_name: 'Imported Data'
+         * });
+         *
+         * // Handle the Excel blob
+         * const blob = excelResponse.data;
+         * const url = URL.createObjectURL(blob);
+         * // Use url for download or further processing
+         * ```
+         */
+        async csvToExcel(lib, csvData, options) {
+            const params = {};
+            if (options === null || options === void 0 ? void 0 : options.sheet_name) {
+                params.sheet_name = options.sheet_name;
+            }
+            return this.request('POST', `media/library/${lib}/convert/csv-to-excel`, {
+                data: csvData,
+                params,
+                responseType: 'blob',
+                headers: {
+                    'Content-Type': 'text/csv'
+                }
+            });
+        }
+        /**
+         * Convert Excel (.xlsx) data to JSON format
+         *
+         * @param lib - Library reference UUID
+         * @param excelData - Excel file data as Blob or ArrayBuffer
+         * @param options - Optional conversion options
+         * @returns Promise resolving to JSON array
+         *
+         * @example
+         * ```typescript
+         * // From file input
+         * const fileInput = document.querySelector('input[type="file"]');
+         * const file = fileInput.files[0]; // Excel file
+         *
+         * const jsonResponse = await dms.excelToJson(libraryRef, file, {
+         *   sheet_name: 'Sheet1' // optional, defaults to first sheet
+         * });
+         *
+         * console.log(jsonResponse.data);
+         * // Output: JSON array with data from Excel sheet
+         *
+         * // From ArrayBuffer
+         * const arrayBuffer = await file.arrayBuffer();
+         * const jsonFromBuffer = await dms.excelToJson(libraryRef, arrayBuffer);
+         * ```
+         */
+        async excelToJson(lib, excelData, options) {
+            const params = {};
+            if (options === null || options === void 0 ? void 0 : options.sheet_name) {
+                params.sheet_name = options.sheet_name;
+            }
+            return this.request('POST', `media/library/${lib}/convert/excel-to-json`, {
+                data: excelData,
+                params,
+                responseType: 'json',
+                headers: {
+                    'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+                }
+            });
+        }
+        /**
+         * Convert Excel (.xlsx) data to CSV format
+         *
+         * @param lib - Library reference UUID
+         * @param excelData - Excel file data as Blob or ArrayBuffer
+         * @param options - Optional conversion options
+         * @returns Promise resolving to CSV string
+         *
+         * @example
+         * ```typescript
+         * // From file input
+         * const fileInput = document.querySelector('input[type="file"]');
+         * const file = fileInput.files[0]; // Excel file
+         *
+         * const csvResponse = await dms.excelToCsv(libraryRef, file, {
+         *   sheet_name: 'Data' // optional, defaults to first sheet
+         * });
+         *
+         * console.log(csvResponse.data);
+         * // Output: CSV string with data from Excel sheet
+         *
+         * // Save as CSV file
+         * const csvBlob = new Blob([csvResponse.data], { type: 'text/csv' });
+         * const url = URL.createObjectURL(csvBlob);
+         * const link = document.createElement('a');
+         * link.href = url;
+         * link.download = 'converted.csv';
+         * link.click();
+         * ```
+         */
+        async excelToCsv(lib, excelData, options) {
+            const params = {};
+            if (options === null || options === void 0 ? void 0 : options.sheet_name) {
+                params.sheet_name = options.sheet_name;
+            }
+            return this.request('POST', `media/library/${lib}/convert/excel-to-csv`, {
+                data: excelData,
+                params,
+                responseType: 'text',
+                headers: {
+                    'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+                }
+            });
+        }
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v2/dms/${endpoint}`,
+                ...params
+            });
+        }
+        async requestv1(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v1/dms/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class SerbiaUtil extends IntegrationsBaseClient {
+        async nbsSearch(params) {
+            return await this.services("GET", "nbs/search", { params });
+        }
+        async getReceiptFromUrl(url, source) {
+            return await this.services("POST", "receipt/crawl", {
+                data: {
+                    url,
+                    source
+                }
+            });
+        }
+        async getContoList() {
+            return await this.services("GET", "conto");
+        }
+        async services(method, endpoint, params) {
+            return this.request(method, `services/${endpoint}`, params);
+        }
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v1/karadjordje/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class VPFR extends IntegrationsBaseClient {
+        async request(method, endpoint, params) {
+            return await this.client.request({
+                method: method,
+                url: `/v1/karadjordje/vpfr/${endpoint}`,
+                ...params
+            });
+        }
+    }
+
+    class Payments extends IntegrationsBaseClient {
+        async getTransactions(userId, params) {
+            return await this.client.get(`/karadjordje/v1/payment/${userId}/list`, {
+                params,
+            });
+        }
+        async getTransaction(provider, userId, transactionId) {
+            return await this.client.get(`/karadjordje/v1/payment/${provider}/${userId}/getTransaction`, {
+                params: { transactionId },
+            });
+        }
+        async settings(provider) {
+            return await this.client.get(`/karadjordje/v1/payment/${provider}/settings`);
+        }
+        async deactivatePaymentLink(provider, user, transactionId) {
+            return await this.client.post(`/karadjordje/v1/payment/${provider}/${user}/deactivate/${transactionId}`);
+        }
+        async voidTransaction(provider, user, transactionId) {
+            return await this.client.post(`/karadjordje/v1/payment/${provider}/${user}/void/${transactionId}`);
+        }
+        async refund(provider, user, transactionId) {
+            return await this.client.post(`/karadjordje/v1/payment/${provider}/${user}/refund/${transactionId}`);
+        }
+        async getPaymentLink(provider, user, options) {
+            return await this.client.post(`/karadjordje/v1/payment/${provider}/${user}/getPaymentLink`, options);
+        }
+        async getTokenRequestLink(provider, user, options) {
+            return await this.client.post(`/karadjordje/v1/payment/${provider}/${user}/getTokenRequestLink`, options);
+        }
+        async directPayUsingToken(provider, user, options) {
+            return await this.client.post(`/karadjordje/v1/payment/${provider}/${user}/directPayUsingToken`, options);
+        }
+    }
+
+    class Minimax extends IntegrationsBaseClient {
+        async settings() {
+            return await this.client.get(`/karadjordje/v1/minimax/settings`);
+        }
+        async getAccounts(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/accounts`;
+            return await this.client.get(path, { params });
+        }
+        async getAccount(userId, organisationId, accountId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/accounts/${accountId}`;
+            return await this.client.get(path);
+        }
+        async getAccountByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/accounts/code(${code})`;
+            return await this.client.get(path);
+        }
+        async getAccountByContent(userId, organisationId, content) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/accounts/content(${content})`;
+            return await this.client.get(path);
+        }
+        async getAccountsForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/accounts/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** ADDRESSES */
+        async getAddresses(userId, organisationId, customerId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses`;
+            return await this.client.get(path, { params });
+        }
+        async newAddress(userId, organisationId, customerId, address) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses`;
+            return await this.client.post(path, address);
+        }
+        async deleteAddress(userId, organisationId, customerId, addressId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses/${addressId}`;
+            return await this.client.delete(path);
+        }
+        async getAddress(userId, organisationId, customerId, addressId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses/${addressId}`;
+            return await this.client.get(path);
+        }
+        async updateAddress(userId, organisationId, customerId, address) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses/${address.AddressId}`;
+            return await this.client.put(path, address);
+        }
+        async getAddressesForSync(userId, organisationId, customerId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** ANALYTICS */
+        async getAnalytics(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/analytics`;
+            return await this.client.get(path, { params });
+        }
+        async newAnalytic(userId, organisationId, analytic) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/analytics`;
+            return await this.client.post(path, analytic);
+        }
+        async deleteAnalytic(userId, organisationId, analyticId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/analytics/${analyticId}`;
+            return await this.client.delete(path);
+        }
+        async getAnalytic(userId, organisationId, analyticId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/analytics/${analyticId}`;
+            return await this.client.get(path);
+        }
+        async updateAnalytic(userId, organisationId, analytic) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/analytics/${analytic.AnalyticId}`;
+            return await this.client.put(path, analytic);
+        }
+        async getAnalyticsForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/analytics/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** BANK ACCOUNTS */
+        async getBankAccounts(userId, organisationId, customerId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/bankAccounts`;
+            return await this.client.get(path, { params });
+        }
+        async newBankAccount(userId, organisationId, customerId, bankAccount) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/bankAccounts`;
+            return await this.client.post(path, bankAccount);
+        }
+        async deleteBankAccount(userId, organisationId, customerId, bankAccountId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/bankAccounts/${bankAccountId}`;
+            return await this.client.delete(path);
+        }
+        async getBankAccount(userId, organisationId, customerId, bankAccountId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/bankAccounts/${bankAccountId}`;
+            return await this.client.get(path);
+        }
+        async updateBankAccount(userId, organisationId, customerId, bankAccount) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses/${bankAccount.BankAccountId}`;
+            return await this.client.put(path, bankAccount);
+        }
+        async getBankAccountsForSync(userId, organisationId, customerId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/bankAccounts/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** CONTACTS */
+        async getCustomerContacts(userId, organisationId, customerId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/contacts`;
+            return await this.client.get(path, { params });
+        }
+        async newContact(userId, organisationId, customerId, contact) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/contacts`;
+            return await this.client.post(path, contact);
+        }
+        async deleteContact(userId, organisationId, customerId, contactId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/contacts/${contactId}`;
+            return await this.client.delete(path);
+        }
+        async getContact(userId, organisationId, customerId, contactId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/contacts/${contactId}`;
+            return await this.client.get(path);
+        }
+        async updateContact(userId, organisationId, customerId, contact) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/addresses/${contact.ContactId}`;
+            return await this.client.put(path, contact);
+        }
+        async getContacts(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/contacts`;
+            return await this.client.get(path, { params });
+        }
+        async getContactForSync(userId, organisationId, customerId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}/contacts/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** COUNTRIES */
+        async getCountries(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/countries`;
+            return await this.client.get(path, { params });
+        }
+        async getCountry(userId, organisationId, countryId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/countries/${countryId}`;
+            return await this.client.get(path);
+        }
+        async getCountryByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/countries/code(${code})`;
+            return await this.client.get(path);
+        }
+        async getCountriesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/countries/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** CURRENCIES */
+        async getCurrencies(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/currencies`;
+            return await this.client.get(path, { params });
+        }
+        async getCurrency(userId, organisationId, currencyId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/currencies/${currencyId}`;
+            return await this.client.get(path);
+        }
+        async getCurrencyByDate(userId, organisationId, date) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/currencies/date(${date.toISOString()})`;
+            return await this.client.get(path);
+        }
+        async getCurrencyByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/currencies/code(${code})`;
+            return await this.client.get(path);
+        }
+        async getCurrenciesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/currencies/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** CUSTOMERS */
+        async getCustomers(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers`;
+            return await this.client.get(path, { params });
+        }
+        async newCustomer(userId, organisationId, customer) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers`;
+            return await this.client.post(path, customer);
+        }
+        async deleteCusomter(userId, organisationId, customerId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}`;
+            return await this.client.delete(path);
+        }
+        async getCustomer(userId, organisationId, customerId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customerId}`;
+            return await this.client.get(path);
+        }
+        async updateCustomer(userId, organisationId, customer) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/${customer.CustomerId}`;
+            return await this.client.put(path, customer);
+        }
+        async getCustomerByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/code(${code})`;
+            return await this.client.get(path);
+        }
+        async newCustomerByTaxNumber(userId, organisationId, taxNumber) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/addbytaxnumber(${taxNumber})`;
+            return await this.client.post(path, {});
+        }
+        async getCustomersForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/customers/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** DASHBOARDS */
+        async getDashboardsData(userId, organisationId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/dashboards`;
+            return await this.client.get(path);
+        }
+        /** DOCUMENTS */
+        async getDocuments(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents`;
+            return await this.client.get(path, { params });
+        }
+        async newDocument(userId, organisationId, document) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents`;
+            return await this.client.post(path, document);
+        }
+        async deleteDocument(userId, organisationId, documentId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/${documentId}`;
+            return await this.client.delete(path);
+        }
+        async getDocument(userId, organisationId, documentId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/${documentId}`;
+            return await this.client.get(path);
+        }
+        async updateDocument(userId, organisationId, document) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/${document.DocumentId}`;
+            return await this.client.put(path, document);
+        }
+        async deleteDocumentAttachment(userId, organisationId, documentId, documentAttachmentId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/${documentId}/attachments/${documentAttachmentId}`;
+            return await this.client.delete(path);
+        }
+        async getDocumentAttachment(userId, organisationId, documentId, documentAttachmentId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/${documentId}/attachments/${documentAttachmentId}`;
+            return await this.client.get(path);
+        }
+        async updateDocumentAttachment(userId, organisationId, documentId, documentAttachment) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/${documentId}/attachments/${documentAttachment.DocumentAttachmentId}`;
+            return await this.client.put(path, documentAttachment);
+        }
+        async newDocumentAttachment(userId, organisationId, documentId, documentAttachment) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/${documentId}/attachments`;
+            return await this.client.post(path, documentAttachment);
+        }
+        async getDocumentsForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/documents/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** DOCUMENT NUMBERINGS */
+        async getDocumentNumberings(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/document-numbering`;
+            return await this.client.get(path, { params });
+        }
+        async getDocumentNumbering(userId, organisationId, documentNumberingId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/document-numbering/${documentNumberingId}`;
+            return await this.client.get(path);
+        }
+        /** EFAKTURA */
+        async getEFakturaList(userId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/efaktura/list`;
+            return await this.client.get(path, { params });
+        }
+        /** EMPLOYEES */
+        async getEmployees(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/employees`;
+            return await this.client.get(path, { params });
+        }
+        async newEmployee(userId, organisationId, employee) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/employees`;
+            return await this.client.post(path, employee);
+        }
+        async deleteEmployee(userId, organisationId, employeeId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/employees/${employeeId}`;
+            return await this.client.delete(path);
+        }
+        async getEmployee(userId, organisationId, employeeId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/employees/${employeeId}`;
+            return await this.client.get(path);
+        }
+        async updateEmployee(userId, organisationId, employee) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/employees/${employee.EmployeeId}`;
+            return await this.client.put(path, employee);
+        }
+        async getEmployeesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/employees/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** EXCHANGE RATES */
+        async getExchangeRate(userId, organisationId, currencyId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/exchange-rates/${currencyId}`;
+            return await this.client.get(path);
+        }
+        async getExchangeRateByCode(userId, organisationId, currencyCode) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/exchange-rates/code(${currencyCode})`;
+            return await this.client.get(path);
+        }
+        /** INBOX */
+        async getInboxes(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/inbox`;
+            return await this.client.get(path, { params });
+        }
+        async newInbox(userId, organisationId, inbox) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/inbox`;
+            return await this.client.post(path, inbox);
+        }
+        async deleteInbox(userId, organisationId, inboxId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/inbox/${inboxId}`;
+            return await this.client.delete(path);
+        }
+        async getInbox(userId, organisationId, inboxId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/inbox/${inboxId}`;
+            return await this.client.get(path);
+        }
+        async newInboxAttachment(userId, organisationId, inboxId, inboxAttachment) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/inbox/${inboxId}`;
+            return await this.client.post(path, inboxAttachment);
+        }
+        async deleteInboxAttachment(userId, organisationId, inboxId, inboxAttachmentId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/inbox/${inboxId}/attachments/${inboxAttachmentId}`;
+            return await this.client.delete(path);
+        }
+        async actionOnInbox(userId, organisationId, inboxId, action) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/inbox/${inboxId}/actions/${action}`;
+            return await this.client.put(path, {});
+        }
+        /** ISSUED INVOICE */
+        async getIssuedInvoices(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices`;
+            return await this.client.get(path, { params });
+        }
+        async newIssuedInvoice(userId, organisationId, issuedInvoice) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices`;
+            return await this.client.post(path, issuedInvoice);
+        }
+        async deleteIssuedInvoice(userId, organisationId, issuedInvoiceId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices/${issuedInvoiceId}`;
+            return await this.client.delete(path);
+        }
+        async getIssuedInvoice(userId, organisationId, issuedInvoiceId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices/${issuedInvoiceId}`;
+            return await this.client.get(path);
+        }
+        async updateIssuedInvoice(userId, organisationId, issuedInvoice) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices/${issuedInvoice.IssuedInvoiceId}`;
+            return await this.client.put(path, issuedInvoice);
+        }
+        async actionOnIssuedInvoice(userId, organisationId, issuedInvoiceId, action) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices/${issuedInvoiceId}/actions/${action}`;
+            return await this.client.put(path, {});
+        }
+        async getIssuedInvoicesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        async getPaymentMethodsOnIssuedInvoices(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoices/paymentmethods`;
+            return await this.client.get(path, { params });
+        }
+        /** ISSUED INVOICE POSTING */
+        async getIssuedInvoicePostings(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoicepostings`;
+            return await this.client.get(path, { params });
+        }
+        async newIssuedInvoicePosting(userId, organisationId, issuedInvoicePosting) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoicepostings`;
+            return await this.client.post(path, issuedInvoicePosting);
+        }
+        async deleteIssuedInvoicePosting(userId, organisationId, issuedInvoicePostingId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoicepostings/${issuedInvoicePostingId}`;
+            return await this.client.delete(path);
+        }
+        async getIssuedInvoicePosting(userId, organisationId, issuedInvoicePostingId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoicepostings/${issuedInvoicePostingId}`;
+            return await this.client.get(path);
+        }
+        async getPaymentMethodsOnIssuedInvoicePostings(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoicepostings/paymentmethods`;
+            return await this.client.get(path, { params });
+        }
+        async actionOnIssuedInvoicePosting(userId, organisationId, issuedInvoicePostingId, action) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/issuedinvoicepostings/${issuedInvoicePostingId}/actions/${action}`;
+            return await this.client.put(path, {});
+        }
+        /** ITEMS */
+        async getItems(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items`;
+            return await this.client.get(path, { params });
+        }
+        async newItem(userId, organisationId, item) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items`;
+            return await this.client.post(path, item);
+        }
+        async deleteItem(userId, organisationId, itemId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/${itemId}`;
+            return await this.client.delete(path);
+        }
+        async getItem(userId, organisationId, itemId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/${itemId}`;
+            return await this.client.get(path);
+        }
+        async updateItem(userId, organisationId, item) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/${item.ItemId}`;
+            return await this.client.put(path, item);
+        }
+        async getItemByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/code(${code})`;
+            return await this.client.get(path);
+        }
+        async getItemSettings(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/settings`;
+            return await this.client.get(path);
+        }
+        async getItemData(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/itemsdata`;
+            return await this.client.get(path, { params });
+        }
+        async getItemPricelist(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/pricelists`;
+            return await this.client.get(path, { params });
+        }
+        async getItemsForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/items/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** JOURNALS */
+        async getJournals(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals`;
+            return await this.client.get(path, { params });
+        }
+        async newJournal(userId, organisationId, journal) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals`;
+            return await this.client.post(path, journal);
+        }
+        async deleteJournal(userId, organisationId, journalId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/${journalId}`;
+            return await this.client.delete(path);
+        }
+        async getJournal(userId, organisationId, journalId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/${journalId}`;
+            return await this.client.get(path);
+        }
+        async updateJournal(userId, organisationId, journal) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/${journal.JournalId}`;
+            return await this.client.put(path, journal);
+        }
+        async deleteJournalVatEntry(userId, organisationId, journalId, vatId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/${journalId}/vat/${vatId}`;
+            return await this.client.delete(path);
+        }
+        async getJournalVatEntry(userId, organisationId, journalId, vatId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/${journalId}/vat/${vatId}`;
+            return await this.client.get(path);
+        }
+        async updateJournalVatEntry(userId, organisationId, journalId, vatEntry) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/${journalId}/vat/${vatEntry.VatEntryId}`;
+            return await this.client.put(path, vatEntry);
+        }
+        async newJournalVatEntry(userId, organisationId, journalId, vatEntry) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/${journalId}/vat`;
+            return await this.client.post(path, vatEntry);
+        }
+        async getJournalsForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        async getJournalsInVODStandard(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/vodstandard`;
+            return await this.client.get(path, { params });
+        }
+        async getJournalEntries(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journals/journal-entries`;
+            return await this.client.get(path, { params });
+        }
+        /** JOURNAL TYPES */
+        async getJournalTypes(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journaltypes`;
+            return await this.client.get(path, { params });
+        }
+        async getJournalType(userId, organisationId, journalTypeId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journaltypes/${journalTypeId}`;
+            return await this.client.get(path);
+        }
+        async getJournalTypeByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journaltypes/code(${code})`;
+            return await this.client.get(path);
+        }
+        async getJournalTypesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/journaltypes/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** ORDERS */
+        async getOrders(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders`;
+            return await this.client.get(path, { params });
+        }
+        async newOrder(userId, organisationId, order) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders`;
+            return await this.client.post(path, order);
+        }
+        async deleteOrder(userId, organisationId, orderId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders/${orderId}`;
+            return await this.client.delete(path);
+        }
+        async getOrder(userId, organisationId, orderId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders/${orderId}`;
+            return await this.client.get(path);
+        }
+        async updateOrder(userId, organisationId, order) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders/${order.OrderId}`;
+            return await this.client.put(path, order);
+        }
+        async actionGetOnOrder(userId, organisationId, orderId, action, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders/${orderId}/actions/${action}`;
+            return await this.client.get(path, { params });
+        }
+        async actionPutOnOrder(userId, organisationId, orderId, action, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders/${orderId}/actions/${action}`;
+            return await this.client.put(path, {}, { params });
+        }
+        async getOrdersForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/orders/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** ORGANISATIONS */
+        async getOrganisation(userId, organisationId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}`;
+            return await this.client.get(path);
+        }
+        async getAllOrganisations(userId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/allOrgs`;
+            return await this.client.get(path, { params });
+        }
+        /** OUTBOX */
+        async getAllOuboxes(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/outbox`;
+            return await this.client.get(path, { params });
+        }
+        async getOutbox(userId, organisationId, outboxId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/outbox/${outboxId}`;
+            return await this.client.get(path);
+        }
+        /** PAYMENT METHODS */
+        async getPaymentMethods(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/paymentmethods`;
+            return await this.client.get(path, { params });
+        }
+        /** PAYROLL SETTINGS */
+        async getPayrollSettingsByCode(userId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/payrollsettings/${code}`;
+            return await this.client.get(path);
+        }
+        /** POSTAL CODE */
+        async getPostalCodesByCountry(userId, organisationId, countryId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/postalcodes/countries/${countryId}`;
+            return await this.client.get(path, { params });
+        }
+        async getPostalCode(userId, organisationId, postalCodeId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/postalcodes/${postalCodeId}`;
+            return await this.client.get(path);
+        }
+        async getPostalCodesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/postalcodes/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** PRODUCT GROUPS */
+        async getProductGroups(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/productGroups`;
+            return await this.client.get(path, { params });
+        }
+        async newProductGroup(userId, organisationId, productGroup) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/productGroups`;
+            return await this.client.post(path, productGroup);
+        }
+        async deleteProductGroup(userId, organisationId, productGroupId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/productGroups/${productGroupId}`;
+            return await this.client.delete(path);
+        }
+        async getProductGroup(userId, organisationId, productGroupId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/productGroups/${productGroupId}`;
+            return await this.client.get(path);
+        }
+        async updateProductGroup(userId, organisationId, productGroup) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/productGroups/${productGroup.ProductGroupId}`;
+            return await this.client.put(path, productGroup);
+        }
+        async getProductGroupsForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/productGroups/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** PURPOSE CODE */
+        async getPurposeCodes(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/purpose-codes`;
+            return await this.client.get(path, { params });
+        }
+        async getPurposeCode(userId, organisationId, purposeCodeId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/purpose-codes/${purposeCodeId}`;
+            return await this.client.get(path);
+        }
+        async getPurposeCodeByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/purpose-codes/code(${code})`;
+            return await this.client.get(path);
+        }
+        async getPurposeCodesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/purpose-codes/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** RECEIVED INVOICES */
+        async deleteReceivedInvoice(userId, organisationId, receivedInvoiceId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/receivedinvoices/${receivedInvoiceId}`;
+            return await this.client.delete(path);
+        }
+        async getReceivedInvoice(userId, organisationId, receivedInvoiceId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/receivedinvoices/${receivedInvoiceId}`;
+            return await this.client.get(path);
+        }
+        async updateReceivedInvoice(userId, organisationId, receivedInvoice) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/receivedinvoices/${receivedInvoice.ReceivedInvoiceId}`;
+            return await this.client.put(path, receivedInvoice);
+        }
+        async getReceivedInvoices(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/receivedinvoices`;
+            return await this.client.get(path, { params });
+        }
+        async newReceivedInvoice(userId, organisationId, receivedInvoice) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/receivedinvoices`;
+            return await this.client.post(path, receivedInvoice);
+        }
+        async getReceivedInvoicesAttachments(userId, organisationId, receivedInvoiceId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/receivedinvoices/${receivedInvoiceId}/attachments`;
+            return await this.client.get(path, { params });
+        }
+        async newReceivedInvoiceAttachment(userId, organisationId, receivedInvoiceId, attachment) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/receivedinvoices/${receivedInvoiceId}/attachments`;
+            return await this.client.post(path, attachment);
+        }
+        /** REPORT TEMPLATES */
+        async getReportTemplates(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/report-templates`;
+            return await this.client.get(path, { params });
+        }
+        async getReportTemplate(userId, organisationId, reportTemplateId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/report-templates/${reportTemplateId}`;
+            return await this.client.get(path);
+        }
+        async getReportTemplatesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/report-templates/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** STOCK */
+        async getStock(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stocks`;
+            return await this.client.get(path, { params });
+        }
+        async getStockForItem(userId, organisationId, itemId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stocks/${itemId}`;
+            return await this.client.get(path);
+        }
+        /** STOCK ENTRIES */
+        async getStockEntries(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stockentry`;
+            return await this.client.get(path, { params });
+        }
+        async newStockEntry(userId, organisationId, stockEntry) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stockentry`;
+            return await this.client.post(path, stockEntry);
+        }
+        async deleteStockEntry(userId, organisationId, stockEntryId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stockentry/${stockEntryId}`;
+            return await this.client.delete(path);
+        }
+        async getStockEntry(userId, organisationId, stockEntryId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stockentry/${stockEntryId}`;
+            return await this.client.get(path);
+        }
+        async updateStockEntry(userId, organisationId, stockEntry) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stockentry/${stockEntry.StockEntryId}`;
+            return await this.client.post(path, stockEntry);
+        }
+        async actionGetOnStockEntry(userId, organisationId, stockEntryId, action, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stockentry/${stockEntryId}/actions/${action}`;
+            return await this.client.get(path, { params });
+        }
+        async actionPutOnStockEntry(userId, organisationId, stockEntryId, action, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/stockentry/${stockEntryId}/actions/${action}`;
+            return await this.client.put(path, {}, { params });
+        }
+        /** USERS */
+        async getCurrentUser(userId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/currentuser/profile`;
+            return await this.client.get(path);
+        }
+        async getCurrentUserOrgs(userId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/currentuser/orgs`;
+            return await this.client.get(path);
+        }
+        /** VAT ACCOUNTING TYPES */
+        async getVatAccountingTypes(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/vataccountingtypes`;
+            return await this.client.get(path, { params });
+        }
+        async getVatAccountingTypesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/vataccountingtypes/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** VAT RATES */
+        async getVatRates(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/vatrates`;
+            return await this.client.get(path, { params });
+        }
+        async getVatRate(userId, organisationId, vatRateId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/vatrates/${vatRateId}`;
+            return await this.client.get(path);
+        }
+        async getVatRateByCode(userId, organisationId, code) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/vatrates/code(${code})`;
+            return await this.client.get(path);
+        }
+        async getVatRatesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/vatrates/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+        /** WAREHOUSES */
+        async getWarehouses(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/warehouses`;
+            return await this.client.get(path, { params });
+        }
+        async newWarehouse(userId, organisationId, warehouse) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/warehouses`;
+            return await this.client.post(path, warehouse);
+        }
+        async deleteWarehouse(userId, organisationId, warehouseId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/warehouses/${warehouseId}`;
+            return await this.client.delete(path);
+        }
+        async getWarehouse(userId, organisationId, warehouseId) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/warehouses/${warehouseId}`;
+            return await this.client.get(path);
+        }
+        async updateWarehouse(userId, organisationId, warehouse) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/warehouses/${warehouse.WarehouseId}`;
+            return await this.client.put(path, warehouse);
+        }
+        async getWarehousesForSync(userId, organisationId, params) {
+            const path = `/karadjordje/v1/minimax/${userId}/api/orgs/${organisationId}/warehouses/synccandidates`;
+            return await this.client.get(path, { params });
+        }
+    }
+
+    // import integrations
+    class Integrations extends IntegrationsBaseClient {
+        constructor(options) {
+            super(options);
+            this.integrations = {
+                'protokol-invoicing': new Invoicing().setClient(this.client),
+                'protokol-vpfr': new VPFR().setClient(this.client),
+                'protokol-dms': new DMS().setClient(this.client),
+                'serbia-utilities': new SerbiaUtil().setClient(this.client),
+                'protokol-payments': new Payments().setClient(this.client),
+                'protokol-minimax': new Minimax().setClient(this.client),
+            };
+        }
+        getSerbiaUtilities() {
+            return this.getInterfaceOf('serbia-utilities');
+        }
+        getDMS() {
+            return this.getInterfaceOf('protokol-dms');
+        }
+        getVPFR() {
+            return this.getInterfaceOf('protokol-vpfr');
+        }
+        getInvoicing() {
+            return this.getInterfaceOf('protokol-invoicing');
+        }
+        getPayments() {
+            return this.getInterfaceOf('protokol-payments');
+        }
+        getMinimax() {
+            return this.getInterfaceOf('protokol-minimax');
+        }
+        async isInstalled(id) {
+            const { data } = await this.client.get("/v1/integrations");
+            return data.find((i) => i.id == id) !== undefined;
+        }
+        getInterfaceOf(id) {
+            try {
+                return this.integrations[id];
+            }
+            catch {
+                throw new Error(`Interface ${id} not provided`);
+            }
+        }
+    }
+
+    // API v0.9 
+    // Export all API modules for version 0.9
+    // This version has specific method signatures and behaviors for v0.9
+
+    exports.APIUser = APIUser;
+    exports.Apps = Apps;
+    exports.Component = Component;
+    exports.ComponentUtils = ComponentUtils;
+    exports.Config = Config;
+    exports.DMS = DMS;
+    exports.Forge = Forge;
+    exports.Functions = Functions;
+    exports.Integration = Integrations;
+    exports.Integrations = Integrations;
+    exports.Invoicing = Invoicing;
+    exports.Payments = Payments;
+    exports.Platform = Platform;
+    exports.Project = Project;
+    exports.Ratchet = Ratchet;
+    exports.Sandbox = Sandbox;
+    exports.SerbiaUtil = SerbiaUtil;
+    exports.System = System;
+    exports.Thunder = Thunder;
+    exports.Users = Users;
+    exports.VPFR = VPFR;
+    exports.Workflow = Workflow;
+    exports.default = Platform;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
+
+})({}, axiosAdapter);