@klardaten/n8n-nodes-datevconnect 1.0.1 → 1.0.3

package/dist/src/services/datevConnectClient.js

@@ -0,0 +1,1809 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticate = authenticate;
+exports.fetchClients = fetchClients;
+exports.fetchClient = fetchClient;
+exports.createClient = createClient;
+exports.updateClient = updateClient;
+exports.fetchClientResponsibilities = fetchClientResponsibilities;
+exports.updateClientResponsibilities = updateClientResponsibilities;
+exports.fetchClientCategories = fetchClientCategories;
+exports.updateClientCategories = updateClientCategories;
+exports.fetchClientGroups = fetchClientGroups;
+exports.updateClientGroups = updateClientGroups;
+exports.fetchClientDeletionLog = fetchClientDeletionLog;
+exports.fetchNextFreeClientNumber = fetchNextFreeClientNumber;
+exports.fetchTaxAuthorities = fetchTaxAuthorities;
+exports.fetchRelationships = fetchRelationships;
+exports.fetchRelationshipTypes = fetchRelationshipTypes;
+exports.fetchLegalForms = fetchLegalForms;
+exports.fetchCorporateStructures = fetchCorporateStructures;
+exports.fetchCorporateStructure = fetchCorporateStructure;
+exports.fetchEstablishment = fetchEstablishment;
+exports.fetchEmployees = fetchEmployees;
+exports.fetchEmployee = fetchEmployee;
+exports.createEmployee = createEmployee;
+exports.updateEmployee = updateEmployee;
+exports.fetchCountryCodes = fetchCountryCodes;
+exports.fetchClientGroupTypes = fetchClientGroupTypes;
+exports.fetchClientGroupType = fetchClientGroupType;
+exports.createClientGroupType = createClientGroupType;
+exports.updateClientGroupType = updateClientGroupType;
+exports.fetchClientCategoryTypes = fetchClientCategoryTypes;
+exports.fetchClientCategoryType = fetchClientCategoryType;
+exports.createClientCategoryType = createClientCategoryType;
+exports.updateClientCategoryType = updateClientCategoryType;
+exports.fetchBanks = fetchBanks;
+exports.fetchAreaOfResponsibilities = fetchAreaOfResponsibilities;
+exports.fetchAddressees = fetchAddressees;
+exports.fetchAddressee = fetchAddressee;
+exports.createAddressee = createAddressee;
+exports.updateAddressee = updateAddressee;
+exports.fetchAddresseesDeletionLog = fetchAddresseesDeletionLog;
+exports.fetchAccountingClients = fetchAccountingClients;
+exports.fetchAccountingClient = fetchAccountingClient;
+exports.fetchFiscalYears = fetchFiscalYears;
+exports.fetchFiscalYear = fetchFiscalYear;
+exports.fetchAccountsReceivable = fetchAccountsReceivable;
+exports.fetchAccountsReceivableCondensed = fetchAccountsReceivableCondensed;
+exports.fetchAccountReceivable = fetchAccountReceivable;
+exports.fetchAccountsPayable = fetchAccountsPayable;
+exports.fetchAccountsPayableCondensed = fetchAccountsPayableCondensed;
+exports.fetchAccountPayable = fetchAccountPayable;
+exports.fetchAccountPostings = fetchAccountPostings;
+exports.fetchAccountPosting = fetchAccountPosting;
+exports.fetchAccountingSequences = fetchAccountingSequences;
+exports.fetchAccountingSequence = fetchAccountingSequence;
+exports.createAccountingSequence = createAccountingSequence;
+exports.fetchAccountingRecords = fetchAccountingRecords;
+exports.fetchAccountingRecord = fetchAccountingRecord;
+exports.fetchPostingProposalRulesIncoming = fetchPostingProposalRulesIncoming;
+exports.fetchPostingProposalRulesOutgoing = fetchPostingProposalRulesOutgoing;
+exports.fetchPostingProposalRulesCashRegister = fetchPostingProposalRulesCashRegister;
+exports.fetchPostingProposalRuleIncoming = fetchPostingProposalRuleIncoming;
+exports.fetchPostingProposalRuleOutgoing = fetchPostingProposalRuleOutgoing;
+exports.fetchPostingProposalRuleCashRegister = fetchPostingProposalRuleCashRegister;
+exports.batchPostingProposalsIncoming = batchPostingProposalsIncoming;
+exports.batchPostingProposalsOutgoing = batchPostingProposalsOutgoing;
+exports.batchPostingProposalsCashRegister = batchPostingProposalsCashRegister;
+exports.fetchAccountingSumsAndBalances = fetchAccountingSumsAndBalances;
+exports.fetchAccountingSumsAndBalance = fetchAccountingSumsAndBalance;
+exports.fetchDebitors = fetchDebitors;
+exports.fetchDebitor = fetchDebitor;
+exports.createDebitor = createDebitor;
+exports.updateDebitor = updateDebitor;
+exports.fetchNextAvailableDebitor = fetchNextAvailableDebitor;
+exports.fetchCreditors = fetchCreditors;
+exports.fetchCreditor = fetchCreditor;
+exports.createCreditor = createCreditor;
+exports.updateCreditor = updateCreditor;
+exports.fetchNextAvailableCreditor = fetchNextAvailableCreditor;
+exports.fetchGeneralLedgerAccounts = fetchGeneralLedgerAccounts;
+exports.fetchGeneralLedgerAccount = fetchGeneralLedgerAccount;
+exports.fetchUtilizedGeneralLedgerAccounts = fetchUtilizedGeneralLedgerAccounts;
+exports.fetchTermsOfPayment = fetchTermsOfPayment;
+exports.fetchTermOfPayment = fetchTermOfPayment;
+exports.createTermOfPayment = createTermOfPayment;
+exports.updateTermOfPayment = updateTermOfPayment;
+exports.fetchStocktakingData = fetchStocktakingData;
+exports.fetchStocktakingDataByAsset = fetchStocktakingDataByAsset;
+exports.updateStocktakingData = updateStocktakingData;
+exports.fetchCostSystems = fetchCostSystems;
+exports.fetchCostSystem = fetchCostSystem;
+exports.fetchCostCenters = fetchCostCenters;
+exports.fetchCostCenter = fetchCostCenter;
+exports.fetchCostCenterProperties = fetchCostCenterProperties;
+exports.fetchCostCenterProperty = fetchCostCenterProperty;
+exports.createInternalCostService = createInternalCostService;
+exports.fetchCostSequences = fetchCostSequences;
+exports.fetchCostSequence = fetchCostSequence;
+exports.createCostSequence = createCostSequence;
+exports.fetchCostAccountingRecords = fetchCostAccountingRecords;
+exports.fetchAccountingStatistics = fetchAccountingStatistics;
+exports.fetchAccountingTransactionKeys = fetchAccountingTransactionKeys;
+exports.fetchAccountingTransactionKey = fetchAccountingTransactionKey;
+exports.fetchVariousAddresses = fetchVariousAddresses;
+exports.fetchVariousAddress = fetchVariousAddress;
+exports.createVariousAddress = createVariousAddress;
+const JSON_CONTENT_TYPE = "application/json";
+const DEFAULT_ERROR_PREFIX = "DATEVconnect request failed";
+function normaliseBaseUrl(host) {
+    if (!host) {
+        throw new Error("DATEVconnect host must be provided");
+    }
+    return host.endsWith("/") ? host : `${host}/`;
+}
+function buildHeaders(headers) {
+    return Object.entries(headers).reduce((acc, [key, value]) => {
+        if (value) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+async function readResponseBody(response) {
+    var _a;
+    const contentType = (_a = response.headers.get("content-type")) !== null && _a !== void 0 ? _a : "";
+    if (contentType.toLowerCase().includes(JSON_CONTENT_TYPE)) {
+        try {
+            return (await response.json());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    try {
+        const text = await response.text();
+        return text.length > 0 ? text : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractErrorMessage(response, body) {
+    const statusPart = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`.trim();
+    const prefix = `${DEFAULT_ERROR_PREFIX}${statusPart ? ` (${statusPart})` : ""}`;
+    if (typeof body === "string" && body.trim().length > 0) {
+        return `${prefix}: ${body.trim()}`;
+    }
+    if (body && typeof body === "object") {
+        const errorDescription = "error_description" in body && typeof body.error_description === "string"
+            ? body.error_description
+            : undefined;
+        const message = ("message" in body && typeof body.message === "string"
+            ? body.message
+            : undefined) ||
+            ("error" in body && typeof body.error === "string" ? body.error : undefined);
+        if (message) {
+            return `${prefix}: ${message}${errorDescription ? `: ${errorDescription}` : ""}`;
+        }
+    }
+    return prefix;
+}
+async function ensureSuccess(response) {
+    const body = await readResponseBody(response);
+    if (!response.ok) {
+        throw new Error(extractErrorMessage(response, body));
+    }
+    if (body && typeof body === "object") {
+        return body;
+    }
+    if (body === undefined) {
+        return undefined;
+    }
+    throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected JSON response body.`);
+}
+async function authenticate(options) {
+    const { host, email, password, fetchImpl = fetch } = options;
+    const baseUrl = normaliseBaseUrl(host);
+    const url = new URL("api/auth/login", baseUrl);
+    const response = await fetchImpl(url, {
+        method: "POST",
+        headers: buildHeaders({
+            "content-type": JSON_CONTENT_TYPE,
+        }),
+        body: JSON.stringify({ email, password }),
+    });
+    const body = await ensureSuccess(response);
+    if (!body || typeof body !== "object" || !("access_token" in body) || typeof body.access_token !== "string") {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Authentication response missing access_token.`);
+    }
+    return body;
+}
+const MASTER_DATA_BASE_PATH = "datevconnect/master-data/v1";
+const CLIENTS_PATH = `${MASTER_DATA_BASE_PATH}/clients`;
+const TAX_AUTHORITIES_PATH = `${MASTER_DATA_BASE_PATH}/tax-authorities`;
+const RELATIONSHIPS_PATH = `${MASTER_DATA_BASE_PATH}/relationships`;
+const RELATIONSHIP_TYPES_PATH = `${MASTER_DATA_BASE_PATH}/relationship-types`;
+const LEGAL_FORMS_PATH = `${MASTER_DATA_BASE_PATH}/legal-forms`;
+const CORPORATE_STRUCTURES_PATH = `${MASTER_DATA_BASE_PATH}/corporate-structures`;
+const EMPLOYEES_PATH = `${MASTER_DATA_BASE_PATH}/employees`;
+const COUNTRY_CODES_PATH = `${MASTER_DATA_BASE_PATH}/country-codes`;
+const CLIENT_GROUP_TYPES_PATH = `${MASTER_DATA_BASE_PATH}/client-group-types`;
+const CLIENT_CATEGORY_TYPES_PATH = `${MASTER_DATA_BASE_PATH}/client-category-types`;
+const BANKS_PATH = `${MASTER_DATA_BASE_PATH}/banks`;
+const AREA_OF_RESPONSIBILITIES_PATH = `${MASTER_DATA_BASE_PATH}/area-of-responsibilities`;
+const ADDRESSEES_PATH = `${MASTER_DATA_BASE_PATH}/addressees`;
+const ADDRESSEES_DELETION_LOG_PATH = `${ADDRESSEES_PATH}/deletion-log`;
+function buildApiUrl(host, path) {
+    const baseUrl = normaliseBaseUrl(host);
+    const trimmedPath = path.startsWith("/") ? path.slice(1) : path;
+    return new URL(trimmedPath, baseUrl);
+}
+async function sendMasterDataRequest(options) {
+    const { host, token, clientInstanceId, path, method, query, body, fetchImpl = fetch } = options;
+    const url = buildApiUrl(host, path);
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null) {
+                continue;
+            }
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const response = await fetchImpl(url, {
+        method,
+        headers: buildHeaders({
+            accept: JSON_CONTENT_TYPE,
+            authorization: `Bearer ${token}`,
+            "content-type": JSON_CONTENT_TYPE,
+            "x-client-instance-id": clientInstanceId,
+        }),
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    return ensureSuccess(response);
+}
+async function fetchClients(options) {
+    const { top, skip, select, filter } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: CLIENTS_PATH,
+        method: "GET",
+        query: {
+            top,
+            skip,
+            select,
+            filter,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected clients payload.`);
+    }
+    return body;
+}
+async function fetchClient(options) {
+    const { clientId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client payload.`);
+    }
+    return body;
+}
+async function createClient(options) {
+    const { client, maxNumber } = options;
+    return sendMasterDataRequest({
+        ...options,
+        path: CLIENTS_PATH,
+        method: "POST",
+        query: {
+            "max-number": maxNumber,
+        },
+        body: client,
+    });
+}
+async function updateClient(options) {
+    const { clientId, client } = options;
+    return sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}`,
+        method: "PUT",
+        body: client,
+    });
+}
+async function fetchClientResponsibilities(options) {
+    const { clientId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}/responsibilities`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected responsibilities payload.`);
+    }
+    return body;
+}
+async function updateClientResponsibilities(options) {
+    const { clientId, responsibilities } = options;
+    return sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}/responsibilities`,
+        method: "PUT",
+        body: responsibilities,
+    });
+}
+async function fetchClientCategories(options) {
+    const { clientId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}/client-categories`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client categories payload.`);
+    }
+    return body;
+}
+async function updateClientCategories(options) {
+    const { clientId, categories } = options;
+    return sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}/client-categories`,
+        method: "PUT",
+        body: categories,
+    });
+}
+async function fetchClientGroups(options) {
+    const { clientId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}/client-groups`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client groups payload.`);
+    }
+    return body;
+}
+async function updateClientGroups(options) {
+    const { clientId, groups } = options;
+    return sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/${encodeURIComponent(clientId)}/client-groups`,
+        method: "PUT",
+        body: groups,
+    });
+}
+async function fetchClientDeletionLog(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/deletion-log`,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client deletion log payload.`);
+    }
+    return body;
+}
+async function fetchNextFreeClientNumber(options) {
+    const { start, range } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENTS_PATH}/next-free-number`,
+        method: "GET",
+        query: {
+            start,
+            range,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected next free number payload.`);
+    }
+    return body;
+}
+async function fetchTaxAuthorities(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: TAX_AUTHORITIES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected tax authorities payload.`);
+    }
+    return body;
+}
+async function fetchRelationships(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: RELATIONSHIPS_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected relationships payload.`);
+    }
+    return body;
+}
+async function fetchRelationshipTypes(options) {
+    const { select, filter } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: RELATIONSHIP_TYPES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected relationship types payload.`);
+    }
+    return body;
+}
+async function fetchLegalForms(options) {
+    const { select, nationalRight, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: LEGAL_FORMS_PATH,
+        method: "GET",
+        query: {
+            select,
+            "national-right": nationalRight,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected legal forms payload.`);
+    }
+    return body;
+}
+async function fetchCorporateStructures(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: CORPORATE_STRUCTURES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected corporate structures payload.`);
+    }
+    return body;
+}
+async function fetchCorporateStructure(options) {
+    const { organizationId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CORPORATE_STRUCTURES_PATH}/${encodeURIComponent(organizationId)}`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected corporate structure payload.`);
+    }
+    return body;
+}
+async function fetchEstablishment(options) {
+    const { organizationId, establishmentId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CORPORATE_STRUCTURES_PATH}/${encodeURIComponent(organizationId)}/establishments/${encodeURIComponent(establishmentId)}`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected establishment payload.`);
+    }
+    return body;
+}
+async function fetchEmployees(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: EMPLOYEES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected employees payload.`);
+    }
+    return body;
+}
+async function fetchEmployee(options) {
+    const { employeeId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${EMPLOYEES_PATH}/${encodeURIComponent(employeeId)}`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected employee payload.`);
+    }
+    return body;
+}
+async function createEmployee(options) {
+    const { employee } = options;
+    return sendMasterDataRequest({
+        ...options,
+        path: EMPLOYEES_PATH,
+        method: "POST",
+        body: employee,
+    });
+}
+async function updateEmployee(options) {
+    const { employeeId, employee } = options;
+    return sendMasterDataRequest({
+        ...options,
+        path: `${EMPLOYEES_PATH}/${encodeURIComponent(employeeId)}`,
+        method: "PUT",
+        body: employee,
+    });
+}
+async function fetchCountryCodes(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: COUNTRY_CODES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected country codes payload.`);
+    }
+    return body;
+}
+async function fetchClientGroupTypes(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: CLIENT_GROUP_TYPES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client group types payload.`);
+    }
+    return body;
+}
+async function fetchClientGroupType(options) {
+    const { clientGroupTypeId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENT_GROUP_TYPES_PATH}/${clientGroupTypeId}`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client group type payload.`);
+    }
+    return body;
+}
+async function createClientGroupType(options) {
+    const { clientGroupType } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: CLIENT_GROUP_TYPES_PATH,
+        method: "POST",
+        body: clientGroupType,
+    });
+    return body;
+}
+async function updateClientGroupType(options) {
+    const { clientGroupTypeId, clientGroupType } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENT_GROUP_TYPES_PATH}/${clientGroupTypeId}`,
+        method: "PUT",
+        body: clientGroupType,
+    });
+    return body;
+}
+async function fetchClientCategoryTypes(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: CLIENT_CATEGORY_TYPES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client category types payload.`);
+    }
+    return body;
+}
+async function fetchClientCategoryType(options) {
+    const { clientCategoryTypeId, select } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENT_CATEGORY_TYPES_PATH}/${clientCategoryTypeId}`,
+        method: "GET",
+        query: {
+            select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected client category type payload.`);
+    }
+    return body;
+}
+async function createClientCategoryType(options) {
+    const { clientCategoryType } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: CLIENT_CATEGORY_TYPES_PATH,
+        method: "POST",
+        body: clientCategoryType,
+    });
+    return body;
+}
+async function updateClientCategoryType(options) {
+    const { clientCategoryTypeId, clientCategoryType } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${CLIENT_CATEGORY_TYPES_PATH}/${clientCategoryTypeId}`,
+        method: "PUT",
+        body: clientCategoryType,
+    });
+    return body;
+}
+async function fetchBanks(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: BANKS_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected banks payload.`);
+    }
+    return body;
+}
+async function fetchAreaOfResponsibilities(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: AREA_OF_RESPONSIBILITIES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected area of responsibilities payload.`);
+    }
+    return body;
+}
+async function fetchAddressees(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: ADDRESSEES_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected addressees payload.`);
+    }
+    return body;
+}
+async function fetchAddressee(options) {
+    const { addresseeId, select, expand } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${ADDRESSEES_PATH}/${addresseeId}`,
+        method: "GET",
+        query: {
+            select,
+            expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected addressee payload.`);
+    }
+    return body;
+}
+async function createAddressee(options) {
+    const { addressee, nationalRight } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: ADDRESSEES_PATH,
+        method: "POST",
+        query: {
+            "national-right": nationalRight,
+        },
+        body: addressee,
+    });
+    return body;
+}
+async function updateAddressee(options) {
+    const { addresseeId, addressee } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: `${ADDRESSEES_PATH}/${addresseeId}`,
+        method: "PUT",
+        body: addressee,
+    });
+    return body;
+}
+async function fetchAddresseesDeletionLog(options) {
+    const { select, filter, top, skip } = options;
+    const body = await sendMasterDataRequest({
+        ...options,
+        path: ADDRESSEES_DELETION_LOG_PATH,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected addressees deletion log payload.`);
+    }
+    return body;
+}
+const ACCOUNTING_BASE_PATH = "datevconnect/accounting/v1";
+async function sendAccountingRequest(options) {
+    const { host, token, clientInstanceId, path, method, query, body, fetchImpl = fetch } = options;
+    const url = buildApiUrl(host, path);
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null) {
+                continue;
+            }
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const response = await fetchImpl(url, {
+        method,
+        headers: buildHeaders({
+            accept: JSON_CONTENT_TYPE,
+            authorization: `Bearer ${token}`,
+            "content-type": JSON_CONTENT_TYPE,
+            "x-client-instance-id": clientInstanceId,
+        }),
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    return ensureSuccess(response);
+}
+async function fetchAccountingClients(options) {
+    const { select, filter, top, skip, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients`,
+        method: "GET",
+        query: {
+            select,
+            filter,
+            top,
+            skip,
+            expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting clients payload.`);
+    }
+    return body;
+}
+async function fetchAccountingClient(options) {
+    const { clientId, select, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}`,
+        method: "GET",
+        query: {
+            select: select,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting client payload.`);
+    }
+    return body;
+}
+async function fetchFiscalYears(options) {
+    const { clientId, select, filter, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected fiscal years payload.`);
+    }
+    return body;
+}
+async function fetchFiscalYear(options) {
+    const { clientId, fiscalYearId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected fiscal year payload.`);
+    }
+    return body;
+}
+async function fetchAccountsReceivable(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounts-receivable`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounts receivable payload.`);
+    }
+    return body;
+}
+async function fetchAccountsReceivableCondensed(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounts-receivable/condensed`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected condensed accounts receivable payload.`);
+    }
+    return body;
+}
+async function fetchAccountReceivable(options) {
+    const { clientId, fiscalYearId, accountsReceivableId, select, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounts-receivable/${encodeURIComponent(accountsReceivableId)}`,
+        method: "GET",
+        query: {
+            select: select,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected account receivable payload.`);
+    }
+    return body;
+}
+async function fetchAccountsPayable(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounts-payable`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounts payable payload.`);
+    }
+    return body;
+}
+async function fetchAccountsPayableCondensed(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounts-payable/condense`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected condensed accounts payable payload.`);
+    }
+    return body;
+}
+async function fetchAccountPayable(options) {
+    const { clientId, fiscalYearId, accountsPayableId, select, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounts-payable/${encodeURIComponent(accountsPayableId)}`,
+        method: "GET",
+        query: {
+            select: select,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected account payable payload.`);
+    }
+    return body;
+}
+async function fetchAccountPostings(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/account-postings`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected account postings payload.`);
+    }
+    return body;
+}
+async function fetchAccountPosting(options) {
+    const { clientId, fiscalYearId, accountPostingId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/account-postings/${encodeURIComponent(accountPostingId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected account posting payload.`);
+    }
+    return body;
+}
+async function fetchAccountingSequences(options) {
+    const { clientId, fiscalYearId, select, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-sequences-processed`,
+        method: "GET",
+        query: {
+            select: select,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting sequences payload.`);
+    }
+    return body;
+}
+async function fetchAccountingSequence(options) {
+    const { clientId, fiscalYearId, accountingSequenceId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-sequences-processed/${encodeURIComponent(accountingSequenceId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting sequence payload.`);
+    }
+    return body;
+}
+async function createAccountingSequence(options) {
+    const { clientId, fiscalYearId, accountingSequence } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-sequences`,
+        method: "POST",
+        body: accountingSequence,
+    });
+}
+async function fetchAccountingRecords(options) {
+    const { clientId, fiscalYearId, accountingSequenceId, select, filter, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-sequences-processed/${encodeURIComponent(accountingSequenceId)}/accounting-records`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting records payload.`);
+    }
+    return body;
+}
+async function fetchAccountingRecord(options) {
+    const { clientId, fiscalYearId, accountingSequenceId, accountingRecordId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-sequences-processed/${encodeURIComponent(accountingSequenceId)}/accounting-records/${encodeURIComponent(accountingRecordId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting record payload.`);
+    }
+    return body;
+}
+async function fetchPostingProposalRulesIncoming(options) {
+    const { clientId, fiscalYearId, select, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposal-rules-incoming-invoices`,
+        method: "GET",
+        query: {
+            select: select,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected posting proposal rules incoming payload.`);
+    }
+    return body;
+}
+async function fetchPostingProposalRulesOutgoing(options) {
+    const { clientId, fiscalYearId, select, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposal-rules-outgoing-invoices`,
+        method: "GET",
+        query: {
+            select: select,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected posting proposal rules outgoing payload.`);
+    }
+    return body;
+}
+async function fetchPostingProposalRulesCashRegister(options) {
+    const { clientId, fiscalYearId, select, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposal-rules-cash-register`,
+        method: "GET",
+        query: {
+            select: select,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected posting proposal rules cash register payload.`);
+    }
+    return body;
+}
+async function fetchPostingProposalRuleIncoming(options) {
+    const { clientId, fiscalYearId, ruleId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposal-rules-incoming-invoices/${encodeURIComponent(ruleId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected posting proposal rule incoming payload.`);
+    }
+    return body;
+}
+async function fetchPostingProposalRuleOutgoing(options) {
+    const { clientId, fiscalYearId, ruleId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposal-rules-outgoing-invoices/${encodeURIComponent(ruleId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected posting proposal rule outgoing payload.`);
+    }
+    return body;
+}
+async function fetchPostingProposalRuleCashRegister(options) {
+    const { clientId, fiscalYearId, ruleId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposal-rules-cash-register/${encodeURIComponent(ruleId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected posting proposal rule cash register payload.`);
+    }
+    return body;
+}
+async function batchPostingProposalsIncoming(options) {
+    const { clientId, fiscalYearId, postingProposals } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposals-incoming-invoices/batch`,
+        method: "POST",
+        body: postingProposals,
+    });
+}
+async function batchPostingProposalsOutgoing(options) {
+    const { clientId, fiscalYearId, postingProposals } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposals-outgoing-invoices/batch`,
+        method: "POST",
+        body: postingProposals,
+    });
+}
+async function batchPostingProposalsCashRegister(options) {
+    const { clientId, fiscalYearId, postingProposals } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/posting-proposals-cash-register/batch`,
+        method: "POST",
+        body: postingProposals,
+    });
+}
+async function fetchAccountingSumsAndBalances(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-sums-and-balances`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting sums and balances payload.`);
+    }
+    return body;
+}
+async function fetchAccountingSumsAndBalance(options) {
+    const { clientId, fiscalYearId, accountingSumsAndBalancesId } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-sums-and-balances/${encodeURIComponent(accountingSumsAndBalancesId)}`,
+        method: "GET",
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting sums and balance payload.`);
+    }
+    return body;
+}
+async function fetchDebitors(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/debitors`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected debitors payload.`);
+    }
+    return body;
+}
+async function fetchDebitor(options) {
+    const { clientId, fiscalYearId, debitorId, select, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/debitors/${encodeURIComponent(debitorId)}`,
+        method: "GET",
+        query: {
+            select: select,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected debitor payload.`);
+    }
+    return body;
+}
+async function createDebitor(options) {
+    const { clientId, fiscalYearId, debitor } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/debitors`,
+        method: "POST",
+        body: debitor,
+    });
+}
+async function updateDebitor(options) {
+    const { clientId, fiscalYearId, debitorId, debitor } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/debitors/${encodeURIComponent(debitorId)}`,
+        method: "PUT",
+        body: debitor,
+    });
+}
+async function fetchNextAvailableDebitor(options) {
+    const { clientId, fiscalYearId, startAt } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/debitors/next-available`,
+        method: "GET",
+        query: {
+            "start-at": startAt,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected next available debitor payload.`);
+    }
+    return body;
+}
+async function fetchCreditors(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/creditors`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected creditors payload.`);
+    }
+    return body;
+}
+async function fetchCreditor(options) {
+    const { clientId, fiscalYearId, creditorId, select, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/creditors/${encodeURIComponent(creditorId)}`,
+        method: "GET",
+        query: {
+            select: select,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected creditor payload.`);
+    }
+    return body;
+}
+async function createCreditor(options) {
+    const { clientId, fiscalYearId, creditor } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/creditors`,
+        method: "POST",
+        body: creditor,
+    });
+}
+async function updateCreditor(options) {
+    const { clientId, fiscalYearId, creditorId, creditor } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/creditors/${encodeURIComponent(creditorId)}`,
+        method: "PUT",
+        body: creditor,
+    });
+}
+async function fetchNextAvailableCreditor(options) {
+    const { clientId, fiscalYearId, startAt } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/creditors/next-available`,
+        method: "GET",
+        query: {
+            "start-at": startAt,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected next available creditor payload.`);
+    }
+    return body;
+}
+async function fetchGeneralLedgerAccounts(options) {
+    const { clientId, fiscalYearId, select, filter, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/general-ledger-accounts`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected general ledger accounts payload.`);
+    }
+    return body;
+}
+async function fetchGeneralLedgerAccount(options) {
+    const { clientId, fiscalYearId, generalLedgerAccountId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/general-ledger-accounts/${encodeURIComponent(generalLedgerAccountId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected general ledger account payload.`);
+    }
+    return body;
+}
+async function fetchUtilizedGeneralLedgerAccounts(options) {
+    const { clientId, fiscalYearId, select, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/general-ledger-accounts/utilized`,
+        method: "GET",
+        query: {
+            select: select,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected utilized general ledger accounts payload.`);
+    }
+    return body;
+}
+// Terms of Payment functions
+async function fetchTermsOfPayment(options) {
+    const { clientId, fiscalYearId, select, filter, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/terms-of-payment`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected terms of payment payload.`);
+    }
+    return body;
+}
+async function fetchTermOfPayment(options) {
+    const { clientId, fiscalYearId, termOfPaymentId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/terms-of-payment/${encodeURIComponent(termOfPaymentId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected term of payment payload.`);
+    }
+    return body;
+}
+async function createTermOfPayment(options) {
+    const { clientId, fiscalYearId, termOfPaymentData } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/terms-of-payment`,
+        method: "POST",
+        body: termOfPaymentData,
+    });
+}
+async function updateTermOfPayment(options) {
+    const { clientId, fiscalYearId, termOfPaymentId, termOfPaymentData } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/terms-of-payment/${encodeURIComponent(termOfPaymentId)}`,
+        method: "PUT",
+        body: termOfPaymentData,
+    });
+}
+// Stocktaking Data functions
+async function fetchStocktakingData(options) {
+    const { clientId, fiscalYearId, filter, select, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/assets/stocktakings`,
+        method: "GET",
+        query: {
+            filter: filter,
+            select: select,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected stocktaking data payload.`);
+    }
+    return body;
+}
+async function fetchStocktakingDataByAsset(options) {
+    const { clientId, fiscalYearId, assetId, select, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/assets/${encodeURIComponent(assetId)}/stocktaking/`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected stocktaking data by asset payload.`);
+    }
+    return body;
+}
+async function updateStocktakingData(options) {
+    const { clientId, fiscalYearId, assetId, stocktakingData } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/assets/${encodeURIComponent(assetId)}/stocktaking/`,
+        method: "PUT",
+        body: stocktakingData,
+    });
+}
+// Cost Systems functions
+async function fetchCostSystems(options) {
+    const { clientId, fiscalYearId, select, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost systems payload.`);
+    }
+    return body;
+}
+async function fetchCostSystem(options) {
+    const { clientId, fiscalYearId, costSystemId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost system payload.`);
+    }
+    return body;
+}
+// Cost Centers functions
+async function fetchCostCenters(options) {
+    const { clientId, fiscalYearId, costSystemId, select, top, skip } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-centers`,
+        method: "GET",
+        query: {
+            select: select,
+            top: top,
+            skip: skip,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost centers payload.`);
+    }
+    return body;
+}
+async function fetchCostCenter(options) {
+    const { clientId, fiscalYearId, costSystemId, costCenterId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-centers/${encodeURIComponent(costCenterId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost center payload.`);
+    }
+    return body;
+}
+// Cost Center Properties functions
+async function fetchCostCenterProperties(options) {
+    const { clientId, fiscalYearId, costSystemId, select, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-center-properties`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost center properties payload.`);
+    }
+    return body;
+}
+async function fetchCostCenterProperty(options) {
+    const { clientId, fiscalYearId, costSystemId, costCenterPropertyId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-center-properties/${encodeURIComponent(costCenterPropertyId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost center property payload.`);
+    }
+    return body;
+}
+// Internal Cost Services functions
+async function createInternalCostService(options) {
+    const { clientId, fiscalYearId, costSystemId, internalCostServiceData } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/internal-cost-services`,
+        method: "POST",
+        body: internalCostServiceData,
+    });
+}
+// Cost Sequences functions
+async function fetchCostSequences(options) {
+    const { clientId, fiscalYearId, costSystemId, select, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-sequences`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost sequences payload.`);
+    }
+    return body;
+}
+async function fetchCostSequence(options) {
+    const { clientId, fiscalYearId, costSystemId, costSequenceId, select } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-sequences/${encodeURIComponent(costSequenceId)}`,
+        method: "GET",
+        query: {
+            select: select,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost sequence payload.`);
+    }
+    return body;
+}
+async function createCostSequence(options) {
+    const { clientId, fiscalYearId, costSystemId, costSequenceId, costSequenceData } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-sequences/${encodeURIComponent(costSequenceId)}`,
+        method: "POST",
+        body: costSequenceData,
+    });
+}
+async function fetchCostAccountingRecords(options) {
+    const { clientId, fiscalYearId, costSystemId, costSequenceId, select, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/cost-systems/${encodeURIComponent(costSystemId)}/cost-sequences/${encodeURIComponent(costSequenceId)}/cost-accounting-records`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected cost accounting records payload.`);
+    }
+    return body;
+}
+// Accounting Statistics functions
+async function fetchAccountingStatistics(options) {
+    const { clientId, fiscalYearId, select, filter, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-statistics`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting statistics payload.`);
+    }
+    return body;
+}
+// Accounting Transaction Keys functions
+async function fetchAccountingTransactionKeys(options) {
+    const { clientId, fiscalYearId, select, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-transaction-keys`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting transaction keys payload.`);
+    }
+    return body;
+}
+async function fetchAccountingTransactionKey(options) {
+    const { clientId, fiscalYearId, accountingTransactionKeyId, select, filter, skip, top } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/accounting-transaction-keys/${encodeURIComponent(accountingTransactionKeyId)}`,
+        method: "GET",
+        query: {
+            select: select,
+            filter: filter,
+            skip: skip,
+            top: top,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected accounting transaction key payload.`);
+    }
+    return body;
+}
+// Various Addresses functions
+async function fetchVariousAddresses(options) {
+    const { clientId, fiscalYearId, select, skip, top, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/various-addresses`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected various addresses payload.`);
+    }
+    return body;
+}
+async function fetchVariousAddress(options) {
+    const { clientId, fiscalYearId, variousAddressId, select, skip, top, expand } = options;
+    const body = await sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/various-addresses/${encodeURIComponent(variousAddressId)}`,
+        method: "GET",
+        query: {
+            select: select,
+            skip: skip,
+            top: top,
+            expand: expand,
+        },
+    });
+    if (body === undefined) {
+        throw new Error(`${DEFAULT_ERROR_PREFIX}: Expected various address payload.`);
+    }
+    return body;
+}
+async function createVariousAddress(options) {
+    const { clientId, fiscalYearId, variousAddressData } = options;
+    return sendAccountingRequest({
+        ...options,
+        path: `${ACCOUNTING_BASE_PATH}/clients/${encodeURIComponent(clientId)}/fiscal-years/${encodeURIComponent(fiscalYearId)}/various-addresses`,
+        method: "POST",
+        body: variousAddressData,
+    });
+}