@ptkl/sdk 0.10.2 → 1.0.0

package/dist/v0.9/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/v0.9/api/integrations/payments.d.ts

@@ -0,0 +1,40 @@
+import IntegrationsBaseClient from "../integrationsBaseClient";
+import { PaymentProvider, Transaction, PaymentAmount } from "../../types/integrations/payments";
+export default class Payments extends IntegrationsBaseClient {
+    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/v0.9/api/integrations/serbiaUtil.d.ts

@@ -0,0 +1,10 @@
+import IntegrationsBaseClient from "../integrationsBaseClient";
+import { NbsIpsQrCode } from "../../types/integrations";
+export default class SerbiaUtil extends IntegrationsBaseClient {
+    nbsSearch(params: any): Promise<import("axios").AxiosResponse<any, any>>;
+    generateNbsIpsQrCode(params: NbsIpsQrCode): any;
+    getReceiptFromUrl(url: string, source: string): Promise<import("axios").AxiosResponse<any, any>>;
+    getContoList(): Promise<import("axios").AxiosResponse<any, any>>;
+    services(method: string, endpoint: string, params?: any): Promise<import("axios").AxiosResponse<any, any>>;
+    request(method: string, endpoint: string, params: any): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/v0.9/api/integrations/vpfr.d.ts

@@ -0,0 +1,4 @@
+import IntegrationsBaseClient from "../integrationsBaseClient";
+export default class VPFR extends IntegrationsBaseClient {
+    request(method: string, endpoint: string, params?: any): Promise<import("axios").AxiosResponse<any, any>>;
+}

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

@@ -0,0 +1,22 @@
+import Invoicing from "./integrations/invoicing";
+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?: {
+        env?: string;
+        token?: string;
+        host?: string;
+    });
+    getSerbiaUtilities(): any;
+    getDMS(): DMS;
+    getVPFR(): VPFR;
+    getInvoicing(): Invoicing;
+    getPayments(): Payments;
+    getMinimax(): Minimax;
+    isInstalled(id: string): Promise<boolean>;
+    getInterfaceOf(id: string): any;
+}

package/dist/v0.9/api/integrationsBaseClient.d.ts

@@ -0,0 +1,11 @@
+import BaseClient from "./baseClient";
+export default class IntegrationsBaseClient extends BaseClient {
+    protected env: string | null;
+    protected token: string | null;
+    protected host: string | null;
+    constructor(options?: {
+        env?: string;
+        token?: string;
+        host?: string;
+    });
+}

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

@@ -0,0 +1,34 @@
+import { AxiosInstance } from "axios";
+import Functions from "./functions";
+import APIUser from "./apiUser";
+import Users from "./users";
+import Apps from "./apps";
+import Component, { ComponentOptions } from "./component";
+import ComponentUtils from "./componentUtils";
+import Thunder from "./thunder";
+import Ratchet from "./ratchet";
+import Sandbox from "./sandbox";
+import System from "./system";
+import Workflow from "./workflow";
+import Forge from "./forge";
+import Project from "./project";
+import Config from "./config";
+import PlatformBaseClient from "./platformBaseClient";
+export default class Platform extends PlatformBaseClient {
+    getPlatformClient(): AxiosInstance;
+    getPlatformBaseURL(): string;
+    apiUser(): APIUser;
+    function(): Functions;
+    user(): Users;
+    app(appType: string): Apps;
+    forge(): Forge;
+    component(ref: string, options?: ComponentOptions): Component;
+    componentUtils(): ComponentUtils;
+    ratchet(): Ratchet;
+    sandbox(): Sandbox;
+    system(): System;
+    workflow(): Workflow;
+    thunder(): Thunder;
+    project(): Project;
+    config(): Config;
+}

package/dist/v0.9/api/platformBaseClient.d.ts

@@ -0,0 +1,27 @@
+import BaseClient from "./baseClient";
+/**
+ * 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.
+ *
+ */
+export default class PlatformBaseClient extends BaseClient {
+    protected env: string | null;
+    protected token: string | null;
+    protected host: string | null;
+    constructor(options?: {
+        env?: string;
+        token?: string;
+        host?: string;
+    });
+}

package/dist/v0.9/api/project.d.ts

@@ -0,0 +1,146 @@
+import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+export default class Project extends PlatformBaseClient {
+    /**
+     * Get list of all projects for the current user
+     */
+    list(): Promise<AxiosResponse<any>>;
+    /**
+     * Create a new project
+     * @param data Project creation data
+     */
+    create(data: {
+        name: string;
+        description?: string;
+        [key: string]: any;
+    }): Promise<AxiosResponse<any>>;
+    /**
+     * Get information about a specific project
+     */
+    info(): Promise<AxiosResponse<any>>;
+    /**
+     * Archive a project
+     */
+    archive(): Promise<AxiosResponse<any>>;
+    /**
+     * Invite a user to the project
+     * @param email Array of emails
+     * @param roles Array of role UUIDs
+     */
+    invite(emails: string[], roles: string[]): Promise<AxiosResponse<any>>;
+    /**
+     * Get list of project invites
+     */
+    getInvites(): Promise<AxiosResponse<any>>;
+    /**
+     * Get a specific invite by UUID
+     * @param uuid Invite UUID
+     */
+    getInvite(uuid: string): Promise<AxiosResponse<any>>;
+    /**
+     * Accept an invite
+     * @param uuid Invite UUID
+     */
+    acceptInvite(uuid: string): Promise<AxiosResponse<any>>;
+    /**
+     * Register through an invite
+     * @param uuid Invite UUID
+     * @param data Registration data
+     */
+    registerWithInvite(uuid: string, data: any): Promise<AxiosResponse<any>>;
+    /**
+     * Get list of project users
+     */
+    getUsers(): Promise<AxiosResponse<any>>;
+    /**
+     * Get a specific project user
+     * @param uuid User UUID
+     */
+    getUser(uuid: string): Promise<AxiosResponse<any>>;
+    /**
+     * Update a project user
+     * @param uuid User UUID
+     * @param data Update data
+     */
+    updateUser(uuid: string, data: any): Promise<AxiosResponse<any>>;
+    /**
+     * Delete a user from the project
+     * @param uuid User UUID
+     */
+    deleteUser(uuid: string): Promise<AxiosResponse<any>>;
+    /**
+     * Update project settings
+     * @param settings Settings data
+     */
+    updateSettings(settings: any): Promise<AxiosResponse<any>>;
+    /**
+     * Create a new workspace
+     * @param data Workspace data
+     */
+    createWorkspace(data: {
+        name: string;
+        description?: string;
+        [key: string]: any;
+    }): Promise<AxiosResponse<any>>;
+    /**
+     * Update a workspace
+     * @param uuid Workspace UUID
+     * @param data Update data
+     */
+    updateWorkspace(uuid: string, data: any): Promise<AxiosResponse<any>>;
+    /**
+     * Delete a workspace
+     * @param uuid Workspace UUID
+     */
+    deleteWorkspace(uuid: string): Promise<AxiosResponse<any>>;
+    /**
+     * Get available templates
+     */
+    getAvailableTemplates(): Promise<AxiosResponse<any>>;
+    /**
+     * Search for templates
+     * @param query Search query
+     */
+    searchTemplates(query: any): Promise<AxiosResponse<any>>;
+    /**
+     * Get template by ID
+     * @param id Template ID
+     */
+    getTemplate(id: string): Promise<AxiosResponse<any>>;
+    /**
+     * Get template by activation code
+     * @param code Activation code
+     */
+    getTemplateByCode(code: string): Promise<AxiosResponse<any>>;
+    /**
+     * Get templates for a workspace
+     */
+    getWorkspaceTemplates(): Promise<AxiosResponse<any>>;
+    /**
+     * Install a template
+     * @param data Installation data
+     */
+    installTemplate(data: {
+        template_id: string;
+        workspace_uuid: string;
+        [key: string]: any;
+    }): Promise<AxiosResponse<any>>;
+    /**
+     * Uninstall a template
+     * @param data Uninstallation data
+     */
+    uninstallTemplate(data: {
+        template_id: string;
+        workspace_uuid: string;
+        [key: string]: any;
+    }): Promise<AxiosResponse<any>>;
+    /**
+     * Upgrade a template
+     * @param data Upgrade data
+     */
+    upgradeTemplate(data: {
+        template_id: string;
+        workspace_uuid: string;
+        [key: string]: any;
+    }): Promise<AxiosResponse<any>>;
+}