@klardaten/n8n-nodes-datevconnect 1.0.2 → 1.0.4

package/dist/src/services/accountingClient.js

@@ -0,0 +1,766 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datevConnectClient = void 0;
+const client = __importStar(require("./datevConnectClient"));
+async function getAuthenticatedOptions(executeFunctions) {
+    const credentials = await executeFunctions.getCredentials("datevConnectApi");
+    // Check if we have a cached token or need to authenticate
+    const authResponse = await client.authenticate({
+        host: credentials.host,
+        email: credentials.email,
+        password: credentials.password,
+    });
+    return {
+        host: credentials.host,
+        token: authResponse.access_token,
+        clientInstanceId: credentials.clientInstanceId,
+    };
+}
+exports.datevConnectClient = {
+    accounting: {
+        async getClients(executeFunctions, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingClients({
+                ...options,
+                ...queryParams,
+            });
+        },
+        async getClient(executeFunctions, clientId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingClient({
+                ...options,
+                clientId,
+                select: queryParams.select,
+                expand: queryParams.expand,
+            });
+        },
+        async getFiscalYears(executeFunctions, clientId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchFiscalYears({
+                ...options,
+                clientId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getFiscalYear(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchFiscalYear({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+            });
+        },
+        async getAccountsReceivable(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountsReceivable({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+                expand: queryParams.expand,
+            });
+        },
+        async getAccountsReceivableCondensed(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountsReceivableCondensed({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getAccountReceivable(executeFunctions, clientId, fiscalYearId, accountsReceivableId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountReceivable({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountsReceivableId,
+                select: queryParams.select,
+                expand: queryParams.expand,
+            });
+        },
+        async getAccountsPayable(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountsPayable({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+                expand: queryParams.expand,
+            });
+        },
+        async getAccountsPayableCondensed(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountsPayableCondensed({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getAccountPayable(executeFunctions, clientId, fiscalYearId, accountsPayableId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountPayable({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountsPayableId,
+                select: queryParams.select,
+                expand: queryParams.expand,
+            });
+        },
+        async getAccountPostings(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountPostings({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getAccountPosting(executeFunctions, clientId, fiscalYearId, accountPostingId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountPosting({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountPostingId,
+                select: queryParams.select,
+            });
+        },
+        async getAccountingSequences(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingSequences({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getAccountingSequence(executeFunctions, clientId, fiscalYearId, accountingSequenceId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingSequence({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountingSequenceId,
+                select: queryParams.select,
+            });
+        },
+        async createAccountingSequence(executeFunctions, clientId, fiscalYearId, accountingSequence) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.createAccountingSequence({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountingSequence,
+            });
+        },
+        async getAccountingRecords(executeFunctions, clientId, fiscalYearId, accountingSequenceId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingRecords({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountingSequenceId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getAccountingRecord(executeFunctions, clientId, fiscalYearId, accountingSequenceId, accountingRecordId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingRecord({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountingSequenceId,
+                accountingRecordId,
+                select: queryParams.select,
+            });
+        },
+        async getPostingProposalRulesIncoming(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchPostingProposalRulesIncoming({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getPostingProposalRulesOutgoing(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchPostingProposalRulesOutgoing({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getPostingProposalRulesCashRegister(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchPostingProposalRulesCashRegister({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getPostingProposalRuleIncoming(executeFunctions, clientId, fiscalYearId, ruleId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchPostingProposalRuleIncoming({
+                ...options,
+                clientId,
+                fiscalYearId,
+                ruleId,
+                select: queryParams.select,
+            });
+        },
+        async getPostingProposalRuleOutgoing(executeFunctions, clientId, fiscalYearId, ruleId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchPostingProposalRuleOutgoing({
+                ...options,
+                clientId,
+                fiscalYearId,
+                ruleId,
+                select: queryParams.select,
+            });
+        },
+        async getPostingProposalRuleCashRegister(executeFunctions, clientId, fiscalYearId, ruleId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchPostingProposalRuleCashRegister({
+                ...options,
+                clientId,
+                fiscalYearId,
+                ruleId,
+                select: queryParams.select,
+            });
+        },
+        async batchPostingProposalsIncoming(executeFunctions, clientId, fiscalYearId, postingProposals) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.batchPostingProposalsIncoming({
+                ...options,
+                clientId,
+                fiscalYearId,
+                postingProposals,
+            });
+        },
+        async batchPostingProposalsOutgoing(executeFunctions, clientId, fiscalYearId, postingProposals) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.batchPostingProposalsOutgoing({
+                ...options,
+                clientId,
+                fiscalYearId,
+                postingProposals,
+            });
+        },
+        async batchPostingProposalsCashRegister(executeFunctions, clientId, fiscalYearId, postingProposals) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.batchPostingProposalsCashRegister({
+                ...options,
+                clientId,
+                fiscalYearId,
+                postingProposals,
+            });
+        },
+        async getAccountingSumsAndBalances(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingSumsAndBalances({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getAccountingSumsAndBalance(executeFunctions, clientId, fiscalYearId, accountingSumsAndBalancesId) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingSumsAndBalance({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountingSumsAndBalancesId,
+            });
+        },
+        async getDebitors(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchDebitors({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+                expand: queryParams.expand,
+            });
+        },
+        async getDebitor(executeFunctions, clientId, fiscalYearId, debitorId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchDebitor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                debitorId,
+                select: queryParams.select,
+                expand: queryParams.expand,
+            });
+        },
+        async createDebitor(executeFunctions, clientId, fiscalYearId, debitor) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.createDebitor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                debitor,
+            });
+        },
+        async updateDebitor(executeFunctions, clientId, fiscalYearId, debitorId, debitor) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.updateDebitor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                debitorId,
+                debitor,
+            });
+        },
+        async getNextAvailableDebitor(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchNextAvailableDebitor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                startAt: queryParams["start-at"],
+            });
+        },
+        async getCreditors(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCreditors({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+                expand: queryParams.expand,
+            });
+        },
+        async getCreditor(executeFunctions, clientId, fiscalYearId, creditorId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCreditor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                creditorId,
+                select: queryParams.select,
+                expand: queryParams.expand,
+            });
+        },
+        async createCreditor(executeFunctions, clientId, fiscalYearId, creditor) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.createCreditor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                creditor,
+            });
+        },
+        async updateCreditor(executeFunctions, clientId, fiscalYearId, creditorId, creditor) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.updateCreditor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                creditorId,
+                creditor,
+            });
+        },
+        async getNextAvailableCreditor(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchNextAvailableCreditor({
+                ...options,
+                clientId,
+                fiscalYearId,
+                startAt: queryParams["start-at"],
+            });
+        },
+        async getGeneralLedgerAccounts(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchGeneralLedgerAccounts({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getGeneralLedgerAccount(executeFunctions, clientId, fiscalYearId, generalLedgerAccountId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchGeneralLedgerAccount({
+                ...options,
+                clientId,
+                fiscalYearId,
+                generalLedgerAccountId,
+                select: queryParams.select,
+            });
+        },
+        async getUtilizedGeneralLedgerAccounts(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchUtilizedGeneralLedgerAccounts({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        // Terms of Payment methods
+        async getTermsOfPayment(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchTermsOfPayment({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        async getTermOfPayment(executeFunctions, clientId, fiscalYearId, termOfPaymentId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchTermOfPayment({
+                ...options,
+                clientId,
+                fiscalYearId,
+                termOfPaymentId,
+                select: queryParams.select,
+            });
+        },
+        async createTermOfPayment(executeFunctions, clientId, fiscalYearId, termOfPaymentData) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.createTermOfPayment({
+                ...options,
+                clientId,
+                fiscalYearId,
+                termOfPaymentData,
+            });
+        },
+        async updateTermOfPayment(executeFunctions, clientId, fiscalYearId, termOfPaymentId, termOfPaymentData) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.updateTermOfPayment({
+                ...options,
+                clientId,
+                fiscalYearId,
+                termOfPaymentId,
+                termOfPaymentData,
+            });
+        },
+        // Stocktaking Data methods
+        async getStocktakingData(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchStocktakingData({
+                ...options,
+                clientId,
+                fiscalYearId,
+                filter: queryParams.filter,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        async getStocktakingDataByAsset(executeFunctions, clientId, fiscalYearId, assetId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchStocktakingDataByAsset({
+                ...options,
+                clientId,
+                fiscalYearId,
+                assetId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        async updateStocktakingData(executeFunctions, clientId, fiscalYearId, assetId, stocktakingData) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.updateStocktakingData({
+                ...options,
+                clientId,
+                fiscalYearId,
+                assetId,
+                stocktakingData,
+            });
+        },
+        // Cost Systems methods
+        async getCostSystems(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostSystems({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        async getCostSystem(executeFunctions, clientId, fiscalYearId, costSystemId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostSystem({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                select: queryParams.select,
+            });
+        },
+        // Cost Centers methods
+        async getCostCenters(executeFunctions, clientId, fiscalYearId, costSystemId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostCenters({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                select: queryParams.select,
+                top: queryParams.top,
+                skip: queryParams.skip,
+            });
+        },
+        async getCostCenter(executeFunctions, clientId, fiscalYearId, costSystemId, costCenterId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostCenter({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                costCenterId,
+                select: queryParams.select,
+            });
+        },
+        // Cost Center Properties methods
+        async getCostCenterProperties(executeFunctions, clientId, fiscalYearId, costSystemId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostCenterProperties({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        async getCostCenterProperty(executeFunctions, clientId, fiscalYearId, costSystemId, costCenterPropertyId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostCenterProperty({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                costCenterPropertyId,
+                select: queryParams.select,
+            });
+        },
+        // Internal Cost Services methods
+        async createInternalCostService(executeFunctions, clientId, fiscalYearId, costSystemId, internalCostServiceData) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.createInternalCostService({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                internalCostServiceData,
+            });
+        },
+        // Cost Sequences methods
+        async getCostSequences(executeFunctions, clientId, fiscalYearId, costSystemId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostSequences({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        async getCostSequence(executeFunctions, clientId, fiscalYearId, costSystemId, costSequenceId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostSequence({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                costSequenceId,
+                select: queryParams.select,
+            });
+        },
+        async createCostSequence(executeFunctions, clientId, fiscalYearId, costSystemId, costSequenceId, costSequenceData) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.createCostSequence({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                costSequenceId,
+                costSequenceData,
+            });
+        },
+        async getCostAccountingRecords(executeFunctions, clientId, fiscalYearId, costSystemId, costSequenceId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchCostAccountingRecords({
+                ...options,
+                clientId,
+                fiscalYearId,
+                costSystemId,
+                costSequenceId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        // Accounting Statistics methods
+        async getAccountingStatistics(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingStatistics({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        // Accounting Transaction Keys methods
+        async getAccountingTransactionKeys(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingTransactionKeys({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        async getAccountingTransactionKey(executeFunctions, clientId, fiscalYearId, accountingTransactionKeyId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchAccountingTransactionKey({
+                ...options,
+                clientId,
+                fiscalYearId,
+                accountingTransactionKeyId,
+                select: queryParams.select,
+                filter: queryParams.filter,
+                skip: queryParams.skip,
+                top: queryParams.top,
+            });
+        },
+        // Various Addresses methods
+        async getVariousAddresses(executeFunctions, clientId, fiscalYearId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchVariousAddresses({
+                ...options,
+                clientId,
+                fiscalYearId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+                expand: queryParams.expand,
+            });
+        },
+        async getVariousAddress(executeFunctions, clientId, fiscalYearId, variousAddressId, queryParams = {}) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.fetchVariousAddress({
+                ...options,
+                clientId,
+                fiscalYearId,
+                variousAddressId,
+                select: queryParams.select,
+                skip: queryParams.skip,
+                top: queryParams.top,
+                expand: queryParams.expand,
+            });
+        },
+        async createVariousAddress(executeFunctions, clientId, fiscalYearId, variousAddressData) {
+            const options = await getAuthenticatedOptions(executeFunctions);
+            return client.createVariousAddress({
+                ...options,
+                clientId,
+                fiscalYearId,
+                variousAddressData,
+            });
+        },
+    },
+};