@ptkl/sdk 0.10.2 → 1.0.0

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

@@ -0,0 +1,2820 @@
+import axios from 'axios';
+
+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.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;
+        }
+        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
+
+export { APIUser, Apps, Component, ComponentUtils, Config, DMS, Forge, Functions, Integrations as Integration, Integrations, Invoicing, Payments, Platform, Project, Ratchet, Sandbox, SerbiaUtil, System, Thunder, Users, VPFR, Workflow, Platform as default };