@ptkl/sdk 1.3.0 → 1.3.2

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

@@ -1,289 +0,0 @@
-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/integrations/payments.d.ts

@@ -1,40 +0,0 @@
-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/integrations/serbiaUtil.d.ts

@@ -1,10 +0,0 @@
-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/integrations/vpfr.d.ts

@@ -1,4 +0,0 @@
-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/integrations.d.ts

@@ -1,22 +0,0 @@
-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/integrationsBaseClient.d.ts

@@ -1,11 +0,0 @@
-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/platform.d.ts

@@ -1,34 +0,0 @@
-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/platformBaseClient.d.ts

@@ -1,27 +0,0 @@
-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/project.d.ts

@@ -1,146 +0,0 @@
-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>>;
-}