@ptkl/sdk 0.10.1 → 0.10.2

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, PDF2HTMLOptions, MediaUploadPayload, MediaUploadBase64Payload } 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
  *
@@ -133,6 +133,15 @@ export default class DMS extends IntegrationsBaseClient {
     createDir(path: string): Promise<AxiosResponse<any, any>>;
     deleteDir(path: string): Promise<AxiosResponse<any, any>>;
     dirs(data: string): 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)
@@ -455,5 +464,6 @@ export default class DMS extends IntegrationsBaseClient {
      */
     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;
 }

package/dist/types/types/component.d.ts

@@ -47,4 +47,38 @@ type UpdateOptions = {
 type ModifyOptions = {
     upsert: boolean;
 };
-export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, };
+type ComponentLabel = {
+    locales: Record<string, string>;
+};
+type ComponentWorkspace = {
+    uuid: string;
+    CreatedAt: string;
+    UpdatedAt: string;
+    DeletedAt: string | null;
+    workspace_uuid: string;
+    component_uuid: string;
+};
+type ComponentListItem = {
+    uuid: string;
+    CreatedAt: string;
+    UpdatedAt: string;
+    DeletedAt: string | null;
+    name: string;
+    label: ComponentLabel;
+    tag: string;
+    icon: string | null;
+    is_active: boolean;
+    is_public: boolean;
+    visible: boolean;
+    project_uuid: string;
+    scope: string;
+    sort: number;
+    public_version: string;
+    dev_version: string;
+    versions: string[] | null;
+    dependencies: string[];
+    workspaces: ComponentWorkspace[];
+    storage_size: number;
+};
+type ComponentListResponse = ComponentListItem[];
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, ComponentListResponse, ComponentListItem, ComponentLabel, ComponentWorkspace, };

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

@@ -52,7 +52,7 @@ export type PDFFillOptions = {
     forms?: PDFFormStructure[] | any;
 };
 export type HTML2PDFOptions = {
-    input_html?: boolean;
+    input_html?: string;
     input_path?: string;
     output_path?: string;
     output_pdf?: boolean;
@@ -206,3 +206,116 @@ export type MediaUploadBase64Payload = {
     /** Array of files with base64-encoded content */
     files: MediaUploadBase64File[];
 };
+/**
+ * Filters for document listing endpoints
+ */
+export type DocumentListParams = {
+    /** Optional text to search within documents */
+    searchText?: string;
+    /** Whether to search recursively through directories */
+    recursive?: boolean;
+};
+export type DocumentSourceType = "component" | string;
+export type DocumentSource = {
+    type: DocumentSourceType;
+    value: string;
+    label: string;
+    tag: string;
+};
+export type DocumentFieldDataMapping = {
+    sourceField?: string;
+};
+export type DocumentFieldSource = "text" | "options" | "datepicker" | DocumentSource["tag"];
+export type DocumentField = {
+    field: string;
+    label?: string | null;
+    source: DocumentFieldSource;
+    value?: string | number | null;
+    format?: string;
+    data?: DocumentFieldDataMapping;
+};
+export type DocumentAuditEntry = {
+    time: string;
+    name?: string;
+    uuid?: string;
+};
+export type DocumentVariant = {
+    name: string;
+    version: number;
+    content: string;
+    sources?: DocumentSource[];
+    fields?: DocumentField[];
+    createdBy?: DocumentAuditEntry;
+    updatedBy?: DocumentAuditEntry;
+    deletedBy?: DocumentAuditEntry;
+};
+export type DocumentResponse = {
+    name: string;
+    variants: DocumentVariant[];
+    createdBy?: DocumentAuditEntry;
+    updatedBy?: DocumentAuditEntry;
+    deletedBy?: DocumentAuditEntry;
+};
+export type DocumentListItem = {
+    name: string;
+    createdBy?: DocumentAuditEntry;
+    updatedBy?: DocumentAuditEntry;
+    deletedBy?: DocumentAuditEntry;
+};
+export type DocumentListResponse = DocumentListItem[];
+/**
+ * Payload for creating a document
+ */
+export type DocumentCreatePayload = {
+    /** Document path (including directory and filename) */
+    path: string;
+    /** Document content (plain text or structured) */
+    content?: string;
+    /** Document variant identifier */
+    variant?: string;
+    /** Optional document sources metadata */
+    sources?: DocumentSource[];
+    /** Optional custom fields metadata */
+    fields?: DocumentField[];
+};
+/**
+ * Payload for updating an existing document
+ */
+export type DocumentUpdatePayload = {
+    /** Document path (including directory and filename) */
+    path: string;
+    /** Variant to update */
+    variant?: string;
+    /** Current version used for optimistic locking */
+    version?: number;
+    /** Updated content */
+    content?: string;
+    /** Updated sources metadata */
+    sources?: DocumentSource[];
+    /** Updated fields metadata */
+    fields?: DocumentField[];
+};
+/**
+ * Payload for restoring a deleted document
+ */
+export type DocumentRestorePayload = {
+    /** Path of the deleted document */
+    path: string;
+    /** Optional new path to restore to */
+    newPath?: string;
+};
+/**
+ * Payload for creating a document comment
+ */
+export type DocumentCommentPayload = {
+    /** Target document path */
+    path: string;
+    /** Comment body */
+    content: string;
+    /** Variant the comment belongs to */
+    variant?: string;
+    /** Comment start position */
+    from?: number;
+    /** Comment end position */
+    to?: number;
+};

package/package.json

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