@ptkl/sdk 0.10.1 → 1.0.0

package/dist/v0.10/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.10/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/{types → v0.10}/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 → v0.10}/api/integrationsBaseClient.d.ts

@@ -1,5 +1,8 @@
 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;

package/dist/{types → v0.10}/api/platform.d.ts

@@ -3,7 +3,7 @@ import Functions from "./functions";
 import APIUser from "./apiUser";
 import Users from "./users";
 import Apps from "./apps";
-import Component from "./component";
+import Component, { ComponentOptions } from "./component";
 import ComponentUtils from "./componentUtils";
 import Thunder from "./thunder";
 import Ratchet from "./ratchet";
@@ -22,7 +22,7 @@ export default class Platform extends PlatformBaseClient {
     user(): Users;
     app(appType: string): Apps;
     forge(): Forge;
-    component(ref: string): Component;
+    component(ref: string, options?: ComponentOptions): Component;
     componentUtils(): ComponentUtils;
     ratchet(): Ratchet;
     sandbox(): Sandbox;

package/dist/v0.10/apiUser.d.ts

@@ -0,0 +1,9 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class APIUser extends PlatformBaseClient {
+    auth(username: string, password: string, project: string): Promise<import("axios").AxiosResponse<any, any>>;
+    newSecret(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+    revokeSecret(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+    edit(uuid: string, roles: string[]): Promise<import("axios").AxiosResponse<any, any>>;
+    list(): Promise<any>;
+    get(uuid: string): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/v0.10/apps.d.ts

@@ -0,0 +1,8 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Apps extends PlatformBaseClient {
+    private appType;
+    constructor(appType?: string);
+    updateSettings(updateValues: any, ref: string): Promise<any>;
+    download(ref: string, version: string): Promise<any>;
+    upload(formData: FormData): Promise<any>;
+}

package/dist/v0.10/baseClient.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from "axios";
+export default class BaseClient {
+    client: AxiosInstance;
+    constructor(client: AxiosInstance);
+    setClient(client: AxiosInstance): this;
+}

package/dist/{types/api → v0.10}/component.d.ts

@@ -1,9 +1,15 @@
-import { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions } from "src/types/component";
+import { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, StreamHandler, AggregateChainable, ComponentOptions } from "./types/component";
 import PlatformBaseClient from "./platformBaseClient";
 import { AxiosResponse } from "axios";
 export default class Component extends PlatformBaseClient {
     private ref;
-    constructor(ref?: string | null);
+    private version;
+    constructor(ref?: string | null, options?: ComponentOptions);
+    /**
+     * Get the base path for component API calls
+     * @private
+     */
+    private getComponentPath;
     /**
      * Find method to search for models
      *
@@ -82,12 +88,41 @@ export default class Component extends PlatformBaseClient {
     concurrentUpdate(uuid: string, version: number, data: Record<string, any>, options: UpdateOptions): Promise<AxiosResponse<any, any>>;
     create(model: Record<string, any>): Promise<AxiosResponse<any, any>>;
     delete(uuid: string): Promise<AxiosResponse<any, any>>;
-    aggregate(pipeline: FindAggregateParams): Promise<AxiosResponse<any, any>>;
+    /**
+     * Execute aggregate pipeline with optional streaming support
+     *
+     * Returns a chainable object that allows both buffered and streaming modes.
+     * Call .onData() to enable streaming mode, or await directly for buffered mode.
+     *
+     * @param {FindAggregateParams} pipeline - MongoDB aggregation pipeline
+     *
+     * @returns {AggregateChainable} Chainable object with streaming methods and Promise interface
+     *
+     * @example
+     * ```typescript
+     * // Buffered response (default, up to 5K documents)
+     * const result = await component.aggregate([{ $match: { status: 'active' } }]);
+     * console.log(result.data); // All results at once
+     *
+     * // Streaming response (up to 25K documents)
+     * await component.aggregate([{ $match: { status: 'active' } }])
+     *   .onData((doc) => console.log('Received:', doc))
+     *   .onError((err) => console.error('Error:', err))
+     *   .onEnd(() => console.log('Stream complete'));
+     * ```
+     */
+    aggregate(pipeline: FindAggregateParams): AggregateChainable;
     settings(): Promise<AxiosResponse<any, any>>;
     saveSettings(settings: any, version: string): Promise<AxiosResponse<any, any>>;
     saveTemplatesDist(version: string, sdkVersion: string, engine: string, dist: Record<string, string>): Promise<any>;
     workflow(event: string, input: any): Promise<AxiosResponse<any, any>>;
     function(name: string, input: any): Promise<AxiosResponse<any, any>>;
     revisions(uuid: string): Promise<AxiosResponse<any, any>>;
+    /**
+     * Internal method to handle NDJSON streaming responses
+     *
+     * @private
+     */
+    private _streamNDJSON;
 }
-export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, };
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, StreamHandler, AggregateChainable, ComponentOptions, };

package/dist/v0.10/componentUtils.d.ts

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

package/dist/v0.10/config.d.ts

@@ -0,0 +1,14 @@
+import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+import { ConfigUpdateRequest, UserConfig } from './types/config';
+export default class Config extends PlatformBaseClient {
+    /**
+     * Get user configuration
+     */
+    getUserConfig(): Promise<AxiosResponse<UserConfig>>;
+    /**
+     * Update user configuration
+     * @param config Configuration data
+     */
+    updateUserConfig(config: ConfigUpdateRequest): Promise<AxiosResponse<any>>;
+}

package/dist/v0.10/forge.d.ts

@@ -0,0 +1,7 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Forge extends PlatformBaseClient {
+    bundleUpload(buffer: Buffer): Promise<any>;
+    getWorkspaceApps(): Promise<any>;
+    removeVersion(ref: string, version: string): Promise<any>;
+    list(): Promise<any>;
+}

package/dist/v0.10/functions.d.ts

@@ -0,0 +1,23 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Functions extends PlatformBaseClient {
+    list(): Promise<any>;
+    get(ref: string): Promise<any>;
+    update(uuid: string, update: any): Promise<any>;
+    /**
+     * Run platform function
+     *
+     * @param id - Function ID
+     * @param input - Input data
+     * @param query - Query parameters
+     * @returns - Function result
+     *
+     * @example
+     * const result = await platform.function().run("myFunction", {input: { foo: "bar" }})
+     */
+    run(id: string, d: {
+        input?: Record<string, any>;
+        query?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Promise<any>;
+    generateSignature(ref: string, env: string): Promise<import("axios").AxiosResponse<any, any>>;
+}