@ptkl/sdk 0.10.0 → 0.10.2

package/dist/package.json

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

package/dist/types/api/componentUtils.d.ts

@@ -1,5 +1,7 @@
+import { AxiosResponse } from "axios";
+import { ComponentListResponse } from "../types/component";
 import PlatformBaseClient from "./platformBaseClient";
 export default class ComponentUtils extends PlatformBaseClient {
-    list(): Promise<import("axios").AxiosResponse<any, any>>;
-    create(data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    list(): Promise<AxiosResponse<ComponentListResponse>>;
+    create(data: any): Promise<AxiosResponse<any, any>>;
 }

package/dist/types/api/integrations/dms.d.ts

@@ -1,6 +1,6 @@
 import IntegrationsBaseClient from "../integrationsBaseClient";
 import { AxiosResponse } from "axios";
-import { PDFFillOptions, DataConversionParams, DataValidationParams, DataInfoParams, DataInfo, DataValidationResult, ConversionOptions, HTML2PDFOptions } from "../../types/integrations";
+import { PDFFillOptions, DataConversionParams, DataValidationParams, DataInfoParams, DataInfo, DataValidationResult, ConversionOptions, HTML2PDFOptions, PDF2HTMLOptions, MediaUploadPayload, MediaUploadBase64Payload, DocumentListParams, DocumentListResponse, DocumentCreatePayload, DocumentUpdatePayload, DocumentRestorePayload, DocumentCommentPayload, DocumentResponse } from "../../types/integrations";
 /**
  * Document Management System (DMS) API client
  *
@@ -83,17 +83,66 @@ import { PDFFillOptions, DataConversionParams, DataValidationParams, DataInfoPar
 export default class DMS extends IntegrationsBaseClient {
     list(data: any): Promise<AxiosResponse<any, any>>;
     libraries(): Promise<AxiosResponse<any, any>>;
-    upload(payload: any): Promise<AxiosResponse<any, any> | undefined>;
+    /**
+     * Upload files using multipart form data
+     *
+     * @param payload - Upload configuration with files, directory, and options
+     * @returns Upload response from the server
+     *
+     * @example
+     * ```typescript
+     * const result = await dms.upload({
+     *   files: [file1, file2],
+     *   uploadDir: '/documents/invoices',
+     *   public: true,
+     *   replace: true,
+     *   metadata: { category: 'finance' }
+     * });
+     * ```
+     */
+    upload(payload: MediaUploadPayload): Promise<AxiosResponse<any, any> | undefined>;
     delete(data: any): Promise<AxiosResponse<any, any>>;
-    uploadBase64(data: any): Promise<AxiosResponse<any, any>>;
-    getMedia(lib: string, key: string, encoding: string): Promise<AxiosResponse<any, any>>;
-    download(lib: string, key: string): Promise<AxiosResponse<any, any>>;
+    /**
+     * Upload files using base64-encoded content
+     *
+     * @param data - Upload payload with base64-encoded files
+     * @returns Upload response from the server
+     *
+     * @example
+     * ```typescript
+     * const result = await dms.uploadBase64({
+     *   path: '/documents/reports',
+     *   is_public: false,
+     *   replace: true,
+     *   files: [
+     *     {
+     *       name: 'report.pdf',
+     *       content_type: 'application/pdf',
+     *       data: 'base64EncodedContent...'
+     *     }
+     *   ]
+     * });
+     * ```
+     */
+    uploadBase64(data: MediaUploadBase64Payload): Promise<AxiosResponse<any, any>>;
+    getMedia(key: string, encoding: string): Promise<AxiosResponse<any, any>>;
+    download(key: string): Promise<AxiosResponse<any, any>>;
     getExifData(key: string): Promise<AxiosResponse<any, any>>;
     html2pdf(data: HTML2PDFOptions): Promise<AxiosResponse<any, any>>;
+    pdf2html(data: PDF2HTMLOptions): Promise<AxiosResponse<any, any>>;
     createDir(path: string): Promise<AxiosResponse<any, any>>;
     deleteDir(path: string): Promise<AxiosResponse<any, any>>;
     dirs(data: string): Promise<AxiosResponse<any, any>>;
-    fillPdf(lib: string, data: PDFFillOptions): Promise<AxiosResponse<any, any>>;
+    createDocument(payload: DocumentCreatePayload): Promise<AxiosResponse<DocumentResponse>>;
+    getDocument(path: string): Promise<AxiosResponse<DocumentResponse>>;
+    getDocumentRaw(path: string): Promise<AxiosResponse<any, any>>;
+    updateDocument(payload: DocumentUpdatePayload): Promise<AxiosResponse<DocumentResponse>>;
+    deleteDocument(path: string): Promise<AxiosResponse<any, any>>;
+    listDocuments(params?: DocumentListParams): Promise<AxiosResponse<DocumentListResponse>>;
+    listDeletedDocuments(params?: DocumentListParams): Promise<AxiosResponse<DocumentListResponse>>;
+    restoreDocument(payload: DocumentRestorePayload): Promise<AxiosResponse<DocumentResponse>>;
+    createDocumentComment(payload: DocumentCommentPayload): Promise<AxiosResponse<any, any>>;
+    fillPdf(data: PDFFillOptions): Promise<AxiosResponse<any, any>>;
     /**
      * Convert data between different formats (JSON, CSV, Excel)
      *
@@ -155,7 +204,7 @@ export default class DMS extends IntegrationsBaseClient {
      * // excelResult.data is a Blob
      * ```
      */
-    convertData(lib: string, data: any, params: DataConversionParams): Promise<AxiosResponse<any>>;
+    convertData(data: any, params: DataConversionParams): Promise<AxiosResponse<any>>;
     /**
      * Get information about data format and structure
      *
@@ -187,7 +236,7 @@ export default class DMS extends IntegrationsBaseClient {
      * // }
      * ```
      */
-    getDataInfo(lib: string, data: any, params: DataInfoParams): Promise<AxiosResponse<DataInfo>>;
+    getDataInfo(data: any, params: DataInfoParams): Promise<AxiosResponse<DataInfo>>;
     /**
      * Validate data format without performing conversion
      *
@@ -222,7 +271,7 @@ export default class DMS extends IntegrationsBaseClient {
      * }
      * ```
      */
-    validateData(lib: string, data: any, params: DataValidationParams): Promise<AxiosResponse<DataValidationResult>>;
+    validateData(data: any, params: DataValidationParams): Promise<AxiosResponse<DataValidationResult>>;
     /**
      * Convert JSON data to CSV format
      *
@@ -261,7 +310,7 @@ export default class DMS extends IntegrationsBaseClient {
      * // Auto-detects header, items, and footer sections
      * ```
      */
-    jsonToCsv(lib: string, jsonData: any, options?: ConversionOptions): Promise<AxiosResponse<string>>;
+    jsonToCsv(jsonData: any, options?: ConversionOptions): Promise<AxiosResponse<string>>;
     /**
      * Convert JSON data to Excel (.xlsx) format
      *
@@ -307,7 +356,7 @@ export default class DMS extends IntegrationsBaseClient {
      * link.click();
      * ```
      */
-    jsonToExcel(lib: string, jsonData: any, options?: ConversionOptions): Promise<AxiosResponse<Blob>>;
+    jsonToExcel(jsonData: any, options?: ConversionOptions): Promise<AxiosResponse<Blob>>;
     /**
      * Convert CSV data to JSON format
      *
@@ -330,7 +379,7 @@ export default class DMS extends IntegrationsBaseClient {
      * // ]
      * ```
      */
-    csvToJson(lib: string, csvData: string): Promise<AxiosResponse<any[]>>;
+    csvToJson(csvData: string): Promise<AxiosResponse<any[]>>;
     /**
      * Convert CSV data to Excel (.xlsx) format
      *
@@ -355,7 +404,7 @@ export default class DMS extends IntegrationsBaseClient {
      * // Use url for download or further processing
      * ```
      */
-    csvToExcel(lib: string, csvData: string, options?: ConversionOptions): Promise<AxiosResponse<Blob>>;
+    csvToExcel(csvData: string, options?: ConversionOptions): Promise<AxiosResponse<Blob>>;
     /**
      * Convert Excel (.xlsx) data to JSON format
      *
@@ -382,7 +431,7 @@ export default class DMS extends IntegrationsBaseClient {
      * const jsonFromBuffer = await dms.excelToJson(libraryRef, arrayBuffer);
      * ```
      */
-    excelToJson(lib: string, excelData: Blob | ArrayBuffer, options?: ConversionOptions): Promise<AxiosResponse<any[]>>;
+    excelToJson(excelData: Blob | ArrayBuffer, options?: ConversionOptions): Promise<AxiosResponse<any[]>>;
     /**
      * Convert Excel (.xlsx) data to CSV format
      *
@@ -413,7 +462,8 @@ export default class DMS extends IntegrationsBaseClient {
      * link.click();
      * ```
      */
-    excelToCsv(lib: string, excelData: Blob | ArrayBuffer, options?: ConversionOptions): Promise<AxiosResponse<string>>;
+    excelToCsv(excelData: Blob | ArrayBuffer, options?: ConversionOptions): Promise<AxiosResponse<string>>;
     request(method: string, endpoint: string, params?: any): Promise<AxiosResponse<any, any>>;
+    requestv2(method: string, endpoint: string, params?: any): Promise<AxiosResponse<any, any>>;
     requestv1(method: string, endpoint: string, params?: any): Promise<AxiosResponse<any, any>>;
 }

package/dist/types/api/integrations/minimax.d.ts

@@ -0,0 +1,289 @@
+import IntegrationsBaseClient from "../integrationsBaseClient";
+import { MinimaxAccount, MinimaxAddress, MinimaxAnalytic, MinimaxBankAccount, MinimaxContact, MinimaxCountry, MinimaxCurrency, MinimaxCustomer, MinimaxDashboardData, MinimaxDocument, MinimaxDocumentAttachment, MinimaxDocumentNumbering, MinimaxEFaktura, MinimaxEmployee, MinimaxExchangeRate, MinimaxInbox, MinimaxInboxAttachment, MinimaxIssuedInvoice, MinimaxIssuedInvoicePosting, MinimaxItem, MinimaxJournal, MinimaxJournalEntry, MinimaxJournalType, MinimaxJournalVatEntry, MinimaxLeanCustomer, MinimaxLeanDocument, MinimaxLeanEmployee, MinimaxLeanIssuedInvoice, MinimaxLeanIssuedInvoicePosting, MinimaxLeanItem, MinimaxLeanJournal, MinimaxLeanOrder, MinimaxLeanReceivedInvoice, MinimaxLeanStockEntry, MinimaxOrder, MinimaxOrganisation, MinimaxOutbox, MinimaxPaymentMethod, MinimaxPayrollSettings, MinimaxPostalCode, MinimaxProductGroup, MinimaxPurposeCode, MinimaxReceivedInvoice, MinimaxReceivedInvoiceAttachment, MinimaxReference, MinimaxReportTemplate, MinimaxSearchParams, MinimaxSearchResult, MinimaxStock, MinimaxStockEntry, MinimaxSyncReference, MinimaxSyncSearchParams, MinimaxUser, MinimaxVatAccountingType, MinimaxVatRate, MinimaxWarehouse } from "../../types/integrations/minimax";
+export default class Minimax extends IntegrationsBaseClient {
+    settings(): Promise<import("axios").AxiosResponse<any, any>>;
+    getAccounts(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxAccount>): Promise<MinimaxSearchResult<MinimaxAccount>>;
+    getAccount(userId: string, organisationId: number, accountId: number): Promise<MinimaxAccount>;
+    getAccountByCode(userId: string, organisationId: number, code: string): Promise<MinimaxAccount>;
+    getAccountByContent(userId: string, organisationId: number, content: string): Promise<MinimaxAccount>;
+    getAccountsForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxAccount>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** ADDRESSES */
+    getAddresses(userId: string, organisationId: number, customerId: number, params?: MinimaxSearchParams<MinimaxAddress>): Promise<MinimaxSearchResult<MinimaxAddress>>;
+    newAddress(userId: string, organisationId: number, customerId: number, address: MinimaxAddress): Promise<{}>;
+    deleteAddress(userId: string, organisationId: number, customerId: number, addressId: number): Promise<{}>;
+    getAddress(userId: string, organisationId: number, customerId: number, addressId: number): Promise<MinimaxAddress>;
+    updateAddress(userId: string, organisationId: number, customerId: number, address: MinimaxAddress): Promise<{}>;
+    getAddressesForSync(userId: string, organisationId: number, customerId: number, params?: MinimaxSyncSearchParams<MinimaxAddress>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** ANALYTICS */
+    getAnalytics(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxAnalytic>): Promise<MinimaxSearchResult<MinimaxAnalytic>>;
+    newAnalytic(userId: string, organisationId: number, analytic: MinimaxAnalytic): Promise<{}>;
+    deleteAnalytic(userId: string, organisationId: number, analyticId: number): Promise<{}>;
+    getAnalytic(userId: string, organisationId: number, analyticId: number): Promise<MinimaxAnalytic>;
+    updateAnalytic(userId: string, organisationId: number, analytic: MinimaxAnalytic): Promise<{}>;
+    getAnalyticsForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxAnalytic>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** BANK ACCOUNTS */
+    getBankAccounts(userId: string, organisationId: number, customerId: number, params?: MinimaxSearchParams<MinimaxBankAccount>): Promise<MinimaxSearchResult<MinimaxBankAccount>>;
+    newBankAccount(userId: string, organisationId: number, customerId: number, bankAccount: MinimaxBankAccount): Promise<{}>;
+    deleteBankAccount(userId: string, organisationId: number, customerId: number, bankAccountId: number): Promise<{}>;
+    getBankAccount(userId: string, organisationId: number, customerId: number, bankAccountId: number): Promise<MinimaxBankAccount>;
+    updateBankAccount(userId: string, organisationId: number, customerId: number, bankAccount: MinimaxBankAccount): Promise<{}>;
+    getBankAccountsForSync(userId: string, organisationId: number, customerId: number, params?: MinimaxSyncSearchParams<MinimaxBankAccount>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** CONTACTS */
+    getCustomerContacts(userId: string, organisationId: number, customerId: number, params?: MinimaxSearchParams<MinimaxContact>): Promise<MinimaxSearchResult<MinimaxContact>>;
+    newContact(userId: string, organisationId: number, customerId: number, contact: MinimaxContact): Promise<{}>;
+    deleteContact(userId: string, organisationId: number, customerId: number, contactId: number): Promise<{}>;
+    getContact(userId: string, organisationId: number, customerId: number, contactId: number): Promise<MinimaxContact>;
+    updateContact(userId: string, organisationId: number, customerId: number, contact: MinimaxContact): Promise<{}>;
+    getContacts(userId: string, organisationId: number, params?: Omit<MinimaxSearchParams<MinimaxContact>, "SearchString"> & {
+        Email?: string;
+    }): Promise<MinimaxSearchResult<MinimaxContact>>;
+    getContactForSync(userId: string, organisationId: number, customerId: number, params?: MinimaxSyncSearchParams<MinimaxContact>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** COUNTRIES */
+    getCountries(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxCountry>): Promise<MinimaxSearchResult<MinimaxCountry>>;
+    getCountry(userId: string, organisationId: number, countryId: number): Promise<MinimaxCountry>;
+    getCountryByCode(userId: string, organisationId: number, code: string): Promise<MinimaxCountry>;
+    getCountriesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxCountry>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** CURRENCIES */
+    getCurrencies(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxCurrency>): Promise<MinimaxSearchResult<MinimaxCurrency>>;
+    getCurrency(userId: string, organisationId: number, currencyId: number): Promise<MinimaxCurrency>;
+    getCurrencyByDate(userId: string, organisationId: number, date: Date): Promise<MinimaxCurrency>;
+    getCurrencyByCode(userId: string, organisationId: number, code: string): Promise<MinimaxCurrency>;
+    getCurrenciesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxCurrency>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** CUSTOMERS */
+    getCustomers(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanCustomer>): Promise<MinimaxSearchResult<MinimaxLeanCustomer>>;
+    newCustomer(userId: string, organisationId: number, customer: MinimaxCustomer): Promise<{}>;
+    deleteCusomter(userId: string, organisationId: number, customerId: number): Promise<{}>;
+    getCustomer(userId: string, organisationId: number, customerId: number): Promise<MinimaxCustomer>;
+    updateCustomer(userId: string, organisationId: number, customer: MinimaxCustomer): Promise<{}>;
+    getCustomerByCode(userId: string, organisationId: number, code: string): Promise<MinimaxCustomer>;
+    newCustomerByTaxNumber(userId: string, organisationId: number, taxNumber: string): Promise<{}>;
+    getCustomersForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxCustomer>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** DASHBOARDS */
+    getDashboardsData(userId: string, organisationId: number): Promise<MinimaxDashboardData>;
+    /** DOCUMENTS */
+    getDocuments(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanDocument>): Promise<MinimaxSearchResult<MinimaxLeanDocument>>;
+    newDocument(userId: string, organisationId: number, document: MinimaxDocument): Promise<{}>;
+    deleteDocument(userId: string, organisationId: number, documentId: number): Promise<{}>;
+    getDocument(userId: string, organisationId: number, documentId: number): Promise<MinimaxDocument>;
+    updateDocument(userId: string, organisationId: number, document: MinimaxDocument): Promise<{}>;
+    deleteDocumentAttachment(userId: string, organisationId: number, documentId: number, documentAttachmentId: number): Promise<{}>;
+    getDocumentAttachment(userId: string, organisationId: number, documentId: number, documentAttachmentId: number): Promise<MinimaxDocumentAttachment>;
+    updateDocumentAttachment(userId: string, organisationId: number, documentId: number, documentAttachment: MinimaxDocumentAttachment): Promise<{}>;
+    newDocumentAttachment(userId: string, organisationId: number, documentId: number, documentAttachment: MinimaxDocumentAttachment): Promise<{}>;
+    getDocumentsForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxDocument>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** DOCUMENT NUMBERINGS */
+    getDocumentNumberings(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxDocumentNumbering>): Promise<MinimaxSearchResult<MinimaxDocumentNumbering>>;
+    getDocumentNumbering(userId: string, organisationId: number, documentNumberingId: number): Promise<MinimaxDocumentNumbering>;
+    /** EFAKTURA */
+    getEFakturaList(userId: string, params?: Omit<MinimaxSearchParams<MinimaxEFaktura>, "SearchString"> & {
+        RegistrationNumber: string;
+        BudgetUserNumber: string;
+        VatIdentificationNumber: string;
+        Name: string;
+    }): Promise<MinimaxSearchResult<MinimaxEFaktura>>;
+    /** EMPLOYEES */
+    getEmployees(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanEmployee>): Promise<MinimaxSearchResult<MinimaxLeanEmployee>>;
+    newEmployee(userId: string, organisationId: number, employee: MinimaxEmployee): Promise<{}>;
+    deleteEmployee(userId: string, organisationId: number, employeeId: number): Promise<{}>;
+    getEmployee(userId: string, organisationId: number, employeeId: number): Promise<MinimaxEmployee>;
+    updateEmployee(userId: string, organisationId: number, employee: MinimaxEmployee): Promise<{}>;
+    getEmployeesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxEmployee>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** EXCHANGE RATES */
+    getExchangeRate(userId: string, organisationId: number, currencyId: number): Promise<MinimaxExchangeRate>;
+    getExchangeRateByCode(userId: string, organisationId: number, currencyCode: string): Promise<MinimaxExchangeRate>;
+    /** INBOX */
+    getInboxes(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxInbox>): Promise<MinimaxSearchResult<MinimaxInbox>>;
+    newInbox(userId: string, organisationId: number, inbox: MinimaxInbox): Promise<{}>;
+    deleteInbox(userId: string, organisationId: number, inboxId: number): Promise<{}>;
+    getInbox(userId: string, organisationId: number, inboxId: number): Promise<MinimaxInbox>;
+    newInboxAttachment(userId: string, organisationId: number, inboxId: number, inboxAttachment: MinimaxInboxAttachment): Promise<{}>;
+    deleteInboxAttachment(userId: string, organisationId: number, inboxId: number, inboxAttachmentId: number): Promise<{}>;
+    actionOnInbox(userId: string, organisationId: number, inboxId: number, action: "approve" | "reject"): Promise<{}>;
+    /** ISSUED INVOICE */
+    getIssuedInvoices(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanIssuedInvoice>): Promise<MinimaxSearchResult<MinimaxLeanIssuedInvoice>>;
+    newIssuedInvoice(userId: string, organisationId: number, issuedInvoice: MinimaxIssuedInvoice): Promise<{}>;
+    deleteIssuedInvoice(userId: string, organisationId: number, issuedInvoiceId: number): Promise<{}>;
+    getIssuedInvoice(userId: string, organisationId: number, issuedInvoiceId: number): Promise<MinimaxIssuedInvoice>;
+    updateIssuedInvoice(userId: string, organisationId: number, issuedInvoice: MinimaxIssuedInvoice): Promise<{}>;
+    actionOnIssuedInvoice(userId: string, organisationId: number, issuedInvoiceId: number, action: "issue" | "issueCancellation" | "generatepdf" | "copytocreditnote" | "copyToReverse" | "issueAndGeneratepdf" | "sendEInvoice"): Promise<{}>;
+    getIssuedInvoicesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxLeanIssuedInvoice>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    getPaymentMethodsOnIssuedInvoices(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxPaymentMethod>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** ISSUED INVOICE POSTING */
+    getIssuedInvoicePostings(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanIssuedInvoicePosting>): Promise<MinimaxSearchResult<MinimaxLeanIssuedInvoicePosting>>;
+    newIssuedInvoicePosting(userId: string, organisationId: number, issuedInvoicePosting: MinimaxIssuedInvoicePosting): Promise<{}>;
+    deleteIssuedInvoicePosting(userId: string, organisationId: number, issuedInvoicePostingId: number): Promise<{}>;
+    getIssuedInvoicePosting(userId: string, organisationId: number, issuedInvoicePostingId: number): Promise<MinimaxIssuedInvoicePosting>;
+    getPaymentMethodsOnIssuedInvoicePostings(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxPaymentMethod>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    actionOnIssuedInvoicePosting(userId: string, organisationId: number, issuedInvoicePostingId: number, action: "issue" | "issueCancellation"): Promise<{}>;
+    /** ITEMS */
+    getItems(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanItem>): Promise<MinimaxSearchResult<MinimaxLeanItem>>;
+    newItem(userId: string, organisationId: number, item: MinimaxItem): Promise<{}>;
+    deleteItem(userId: string, organisationId: number, itemId: number): Promise<{}>;
+    getItem(userId: string, organisationId: number, itemId: number): Promise<MinimaxItem>;
+    updateItem(userId: string, organisationId: number, item: MinimaxItem): Promise<{}>;
+    getItemByCode(userId: string, organisationId: number, code: string): Promise<MinimaxItem>;
+    getItemSettings(userId: string, organisationId: number, code: string): Promise<{
+        PricesIncludeVAT: string;
+    }>;
+    getItemData(userId: string, organisationId: number, params: {
+        WarehouseId: number;
+        CustomerId: number;
+        ItemId: number;
+    }): Promise<{
+        Rows: (Pick<MinimaxItem, "Title" | "Code" | "Price" | "UnitOfMeasurement"> & {
+            Item: MinimaxReference;
+            Warehouse: MinimaxReference;
+            Customer: MinimaxReference;
+        })[];
+        ValidationMessages: {
+            Message: string;
+            PropertyName: string;
+        }[];
+    }>;
+    getItemPricelist(userId: string, organisationId: number, params: {
+        WarehouseId: number;
+        CustomerId: number;
+        ItemId: number;
+    }): Promise<{
+        Rows: (Pick<MinimaxItem, "Title" | "Code" | "UnitOfMeasurement"> & {
+            PriceWithoutVAT: number;
+            PriceWithVAT: number;
+            Item: MinimaxReference;
+            Warehouse: MinimaxReference;
+            Customer: MinimaxReference;
+        })[];
+        ValidationMessages: {
+            Message: string;
+            PropertyName: string;
+        }[];
+    }>;
+    getItemsForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxLeanItem>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** JOURNALS */
+    getJournals(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanJournal>): Promise<MinimaxSearchResult<MinimaxLeanJournal>>;
+    newJournal(userId: string, organisationId: number, journal: MinimaxJournal): Promise<{}>;
+    deleteJournal(userId: string, organisationId: number, journalId: number): Promise<{}>;
+    getJournal(userId: string, organisationId: number, journalId: number): Promise<MinimaxJournal>;
+    updateJournal(userId: string, organisationId: number, journal: MinimaxJournal): Promise<{}>;
+    deleteJournalVatEntry(userId: string, organisationId: number, journalId: number, vatId: number): Promise<{}>;
+    getJournalVatEntry(userId: string, organisationId: number, journalId: number, vatId: number): Promise<MinimaxJournalVatEntry>;
+    updateJournalVatEntry(userId: string, organisationId: number, journalId: number, vatEntry: MinimaxJournalVatEntry): Promise<{}>;
+    newJournalVatEntry(userId: string, organisationId: number, journalId: number, vatEntry: MinimaxJournalVatEntry): Promise<{}>;
+    getJournalsForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxLeanJournal>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    getJournalsInVODStandard(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxLeanJournal> & {
+        DateTo?: string;
+        DateFrom?: string;
+        JournalId?: number;
+        FromJournalId?: number;
+    }): Promise<{
+        Version: string;
+        Content: string;
+        StatusCode: string;
+        ReasonPhrase: string;
+        Headers: string;
+        RequestMessage: string;
+        IsSuccessStatusCode: string;
+    }>;
+    getJournalEntries(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxJournalEntry>): Promise<MinimaxSearchResult<MinimaxJournalEntry>>;
+    /** JOURNAL TYPES */
+    getJournalTypes(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxJournalType>): Promise<MinimaxSearchResult<MinimaxJournalType>>;
+    getJournalType(userId: string, organisationId: number, journalTypeId: number): Promise<MinimaxJournalType>;
+    getJournalTypeByCode(userId: string, organisationId: number, code: string): Promise<MinimaxJournalType>;
+    getJournalTypesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxJournalType>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** ORDERS */
+    getOrders(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanOrder>): Promise<MinimaxSearchResult<MinimaxLeanOrder>>;
+    newOrder(userId: string, organisationId: number, order: MinimaxOrder): Promise<{}>;
+    deleteOrder(userId: string, organisationId: number, orderId: number): Promise<{}>;
+    getOrder(userId: string, organisationId: number, orderId: number): Promise<MinimaxOrder>;
+    updateOrder(userId: string, organisationId: number, order: MinimaxOrder): Promise<{}>;
+    actionGetOnOrder(userId: string, organisationId: number, orderId: number, action: "getorderpdf", params?: {
+        rowVersion?: string;
+    }): Promise<{}>;
+    actionPutOnOrder(userId: string, organisationId: number, orderId: number, action: "confirm" | "cancelConfirmation" | "complete" | "cancelCompletion" | "invalidate" | "cancelInvalidation" | "createissuedinvoice" | "generatepdf", params?: {
+        rowVersion?: string;
+    }): Promise<{}>;
+    getOrdersForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxLeanOrder>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** ORGANISATIONS */
+    getOrganisation(userId: string, organisationId: number): Promise<MinimaxOrganisation>;
+    getAllOrganisations(userId: string, params: {
+        startRowIndex: number;
+        endRowIndex: number;
+        searchString: string;
+    }): Promise<MinimaxSearchResult<MinimaxOrganisation>>;
+    /** OUTBOX */
+    getAllOuboxes(userId: string, organisationId: number, params: MinimaxSearchParams<MinimaxOutbox> & {
+        OutboxType?: string;
+        OutboxImportStatus?: string;
+        OutboxDateFrom?: string;
+        OutboxDateTo?: string;
+    }): Promise<MinimaxSearchResult<MinimaxOutbox>>;
+    getOutbox(userId: string, organisationId: number, outboxId: number): Promise<MinimaxOutbox>;
+    /** PAYMENT METHODS */
+    getPaymentMethods(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxPaymentMethod>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** PAYROLL SETTINGS */
+    getPayrollSettingsByCode(userId: string, code: string): Promise<MinimaxPayrollSettings>;
+    /** POSTAL CODE */
+    getPostalCodesByCountry(userId: string, organisationId: number, countryId: number, params?: MinimaxSearchParams<MinimaxPostalCode>): Promise<MinimaxSearchResult<MinimaxPostalCode>>;
+    getPostalCode(userId: string, organisationId: number, postalCodeId: number): Promise<MinimaxPostalCode>;
+    getPostalCodesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxPostalCode>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** PRODUCT GROUPS */
+    getProductGroups(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxProductGroup>): Promise<MinimaxSearchResult<MinimaxProductGroup>>;
+    newProductGroup(userId: string, organisationId: number, productGroup: MinimaxProductGroup): Promise<{}>;
+    deleteProductGroup(userId: string, organisationId: number, productGroupId: number): Promise<{}>;
+    getProductGroup(userId: string, organisationId: number, productGroupId: number): Promise<MinimaxProductGroup>;
+    updateProductGroup(userId: string, organisationId: number, productGroup: MinimaxProductGroup): Promise<{}>;
+    getProductGroupsForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxProductGroup>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** PURPOSE CODE */
+    getPurposeCodes(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxPurposeCode>): Promise<MinimaxSearchResult<MinimaxPurposeCode>>;
+    getPurposeCode(userId: string, organisationId: number, purposeCodeId: number): Promise<MinimaxPurposeCode>;
+    getPurposeCodeByCode(userId: string, organisationId: number, code: string): Promise<MinimaxPurposeCode>;
+    getPurposeCodesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxPurposeCode>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** RECEIVED INVOICES */
+    deleteReceivedInvoice(userId: string, organisationId: number, receivedInvoiceId: number): Promise<{}>;
+    getReceivedInvoice(userId: string, organisationId: number, receivedInvoiceId: number): Promise<MinimaxReceivedInvoice>;
+    updateReceivedInvoice(userId: string, organisationId: number, receivedInvoice: MinimaxReceivedInvoice): Promise<{}>;
+    getReceivedInvoices(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanReceivedInvoice>): Promise<MinimaxSearchResult<MinimaxLeanReceivedInvoice>>;
+    newReceivedInvoice(userId: string, organisationId: number, receivedInvoice: MinimaxReceivedInvoice): Promise<{}>;
+    getReceivedInvoicesAttachments(userId: string, organisationId: number, receivedInvoiceId: number, params?: MinimaxSearchParams<MinimaxReceivedInvoiceAttachment>): Promise<MinimaxSearchResult<MinimaxReceivedInvoiceAttachment>>;
+    newReceivedInvoiceAttachment(userId: string, organisationId: number, receivedInvoiceId: number, attachment: MinimaxReceivedInvoiceAttachment): Promise<{}>;
+    /** REPORT TEMPLATES */
+    getReportTemplates(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxReportTemplate>): Promise<MinimaxSearchResult<MinimaxReportTemplate>>;
+    getReportTemplate(userId: string, organisationId: number, reportTemplateId: number): Promise<MinimaxReportTemplate>;
+    getReportTemplatesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxReportTemplate>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** STOCK */
+    getStock(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxStock>): Promise<MinimaxSearchResult<MinimaxStock>>;
+    getStockForItem(userId: string, organisationId: number, itemId: number): Promise<MinimaxStock>;
+    /** STOCK ENTRIES */
+    getStockEntries(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxLeanStockEntry>): Promise<MinimaxSearchResult<MinimaxLeanStockEntry>>;
+    newStockEntry(userId: string, organisationId: number, stockEntry: MinimaxStockEntry): Promise<{}>;
+    deleteStockEntry(userId: string, organisationId: number, stockEntryId: number): Promise<{}>;
+    getStockEntry(userId: string, organisationId: number, stockEntryId: number): Promise<MinimaxStockEntry>;
+    updateStockEntry(userId: string, organisationId: number, stockEntry: MinimaxStockEntry): Promise<{}>;
+    actionGetOnStockEntry(userId: string, organisationId: number, stockEntryId: number, action: "getDeliveryNotepdf", params?: {
+        rowVersion?: string;
+    }): Promise<{}>;
+    actionPutOnStockEntry(userId: string, organisationId: number, stockEntryId: number, action: "confirm" | "cancelConfirmation", params?: {
+        rowVersion?: string;
+    }): Promise<{}>;
+    /** USERS */
+    getCurrentUser(userId: string): Promise<MinimaxUser>;
+    getCurrentUserOrgs(userId: string): Promise<MinimaxSearchResult<{
+        Organisation: MinimaxReference;
+        APIAccess: string;
+        MobileAccess: string;
+    }>>;
+    /** VAT ACCOUNTING TYPES */
+    getVatAccountingTypes(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxVatAccountingType>): Promise<MinimaxSearchResult<MinimaxVatAccountingType>>;
+    getVatAccountingTypesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxVatAccountingType>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** VAT RATES */
+    getVatRates(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxVatRate>): Promise<MinimaxSearchResult<MinimaxVatRate>>;
+    getVatRate(userId: string, organisationId: number, vatRateId: number): Promise<MinimaxVatRate>;
+    getVatRateByCode(userId: string, organisationId: number, code: string): Promise<MinimaxVatRate>;
+    getVatRatesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxVatRate>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+    /** WAREHOUSES */
+    getWarehouses(userId: string, organisationId: number, params?: MinimaxSearchParams<MinimaxWarehouse>): Promise<MinimaxSearchResult<MinimaxWarehouse>>;
+    newWarehouse(userId: string, organisationId: number, warehouse: MinimaxWarehouse): Promise<{}>;
+    deleteWarehouse(userId: string, organisationId: number, warehouseId: number): Promise<{}>;
+    getWarehouse(userId: string, organisationId: number, warehouseId: number): Promise<MinimaxWarehouse>;
+    updateWarehouse(userId: string, organisationId: number, warehouse: MinimaxWarehouse): Promise<{}>;
+    getWarehousesForSync(userId: string, organisationId: number, params?: MinimaxSyncSearchParams<MinimaxWarehouse>): Promise<MinimaxSearchResult<MinimaxSyncReference>>;
+}

package/dist/types/api/integrations/payments.d.ts

@@ -1,7 +1,40 @@
 import IntegrationsBaseClient from "../integrationsBaseClient";
-import { PaymentProvider, GetPaymentLinkOptions } from "../../types/integrations";
+import { PaymentProvider, Transaction, PaymentAmount } from "../../types/integrations/payments";
 export default class Payments extends IntegrationsBaseClient {
-    getTransactions(user: string): Promise<import("axios").AxiosResponse<any, any>>;
-    settings(provider: PaymentProvider): Promise<import("axios").AxiosResponse<any, any>>;
-    getPaymentLink(provider: PaymentProvider, user: string, options: GetPaymentLinkOptions): Promise<import("axios").AxiosResponse<any, any>>;
+    getTransactions(userId: string, params?: {
+        status: string;
+        sortBy: string;
+        sortDirection: string;
+        limit: number;
+        page: number;
+    }): Promise<{
+        transactions: Transaction[];
+        totalCount: number;
+        currentPage: number;
+        pageSize: number;
+    }>;
+    getTransaction(provider: PaymentProvider, userId: string, transactionId: string): Promise<Transaction>;
+    settings(provider: PaymentProvider): Promise<{
+        merchant_key: string;
+        authenticity_token: string;
+    }>;
+    deactivatePaymentLink(provider: PaymentProvider, user: string, transactionId: string): Promise<import("axios").AxiosResponse<any, any>>;
+    voidTransaction(provider: PaymentProvider, user: string, transactionId: string): Promise<import("axios").AxiosResponse<any, any>>;
+    refund(provider: PaymentProvider, user: string, transactionId: string): Promise<import("axios").AxiosResponse<any, any>>;
+    getPaymentLink(provider: PaymentProvider, user: string, options: PaymentAmount & {
+        description: string;
+        token?: string;
+        isTokenRequest?: boolean;
+        redirectUrl?: string;
+        lang?: "en" | "es" | "ba" | "hr";
+    }): Promise<import("axios").AxiosResponse<any, any>>;
+    getTokenRequestLink(provider: PaymentProvider, user: string, options: {
+        description: string;
+        redirectUrl?: string;
+        lang?: "en" | "es" | "ba" | "hr";
+    }): Promise<import("axios").AxiosResponse<any, any>>;
+    directPayUsingToken(provider: PaymentProvider, user: string, options: PaymentAmount & {
+        description: string;
+        token: string;
+    }): Promise<import("axios").AxiosResponse<any, any>>;
 }

package/dist/types/api/integrations.d.ts

@@ -3,6 +3,7 @@ import DMS from "./integrations/dms";
 import VPFR from "./integrations/vpfr";
 import IntegrationsBaseClient from "./integrationsBaseClient";
 import Payments from "./integrations/payments";
+import Minimax from "./integrations/minimax";
 export default class Integrations extends IntegrationsBaseClient {
     private integrations;
     constructor(options?: {
@@ -15,6 +16,7 @@ export default class Integrations extends IntegrationsBaseClient {
     getVPFR(): VPFR;
     getInvoicing(): Invoicing;
     getPayments(): Payments;
+    getMinimax(): Minimax;
     isInstalled(id: string): Promise<boolean>;
     getInterfaceOf(id: string): any;
 }