@promptpartner/bexio-mcp-server 2.0.0

package/dist/bexio-client.js

@@ -0,0 +1,1045 @@
+/**
+ * Bexio API Client.
+ * Handles all HTTP communication with the Bexio API.
+ * Uses logger for all output (no console.log).
+ */
+import axios from "axios";
+import { logger } from "./logger.js";
+import { McpError } from "./shared/errors.js";
+export class BexioClient {
+    client;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.client = axios.create({
+            baseURL: config.baseUrl,
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+            timeout: 30000,
+        });
+        // Add response interceptor for error handling
+        this.client.interceptors.response.use((response) => response, (error) => {
+            if (error.response) {
+                const status = error.response.status;
+                const message = error.response.data?.message || error.response.statusText;
+                throw McpError.bexioApi(message, status, {
+                    url: error.config?.url,
+                    method: error.config?.method,
+                });
+            }
+            else if (error.request) {
+                throw McpError.bexioApi("No response received from server", undefined, {
+                    error: "NETWORK_ERROR",
+                });
+            }
+            else {
+                throw McpError.internal(error.message);
+            }
+        });
+    }
+    async makeRequest(method, endpoint, params, data) {
+        logger.debug(`${method} ${endpoint}`, { params, hasData: !!data });
+        const response = await this.client.request({
+            method,
+            url: endpoint,
+            params,
+            data,
+        });
+        return response.data;
+    }
+    // ===== CONTACT GROUPS =====
+    async listContactGroups(params = {}) {
+        return this.makeRequest("GET", "/contact_group", params);
+    }
+    async getContactGroup(groupId) {
+        return this.makeRequest("GET", `/contact_group/${groupId}`);
+    }
+    async createContactGroup(data) {
+        return this.makeRequest("POST", "/contact_group", undefined, data);
+    }
+    async deleteContactGroup(groupId) {
+        return this.makeRequest("DELETE", `/contact_group/${groupId}`);
+    }
+    // ===== CONTACT SECTORS =====
+    async listContactSectors(params = {}) {
+        return this.makeRequest("GET", "/contact_sector", params);
+    }
+    async getContactSector(sectorId) {
+        return this.makeRequest("GET", `/contact_sector/${sectorId}`);
+    }
+    async createContactSector(data) {
+        return this.makeRequest("POST", "/contact_sector", undefined, data);
+    }
+    // ===== SALUTATIONS =====
+    async listSalutations(params = {}) {
+        return this.makeRequest("GET", "/salutation", params);
+    }
+    async getSalutation(salutationId) {
+        return this.makeRequest("GET", `/salutation/${salutationId}`);
+    }
+    async createSalutation(data) {
+        return this.makeRequest("POST", "/salutation", undefined, data);
+    }
+    async deleteSalutation(salutationId) {
+        return this.makeRequest("DELETE", `/salutation/${salutationId}`);
+    }
+    // ===== TITLES =====
+    async listTitles(params = {}) {
+        return this.makeRequest("GET", "/title", params);
+    }
+    async getTitle(titleId) {
+        return this.makeRequest("GET", `/title/${titleId}`);
+    }
+    async createTitle(data) {
+        return this.makeRequest("POST", "/title", undefined, data);
+    }
+    async deleteTitle(titleId) {
+        return this.makeRequest("DELETE", `/title/${titleId}`);
+    }
+    // ===== COUNTRIES =====
+    async listCountries(params = {}) {
+        return this.makeRequest("GET", "/country", params);
+    }
+    async getCountry(countryId) {
+        return this.makeRequest("GET", `/country/${countryId}`);
+    }
+    async createCountry(data) {
+        return this.makeRequest("POST", "/country", undefined, data);
+    }
+    async deleteCountry(countryId) {
+        return this.makeRequest("DELETE", `/country/${countryId}`);
+    }
+    // ===== LANGUAGES =====
+    async listLanguages(params = {}) {
+        return this.makeRequest("GET", "/language", params);
+    }
+    async getLanguage(languageId) {
+        return this.makeRequest("GET", `/language/${languageId}`);
+    }
+    async createLanguage(data) {
+        return this.makeRequest("POST", "/language", undefined, data);
+    }
+    // ===== UNITS =====
+    async listUnits(params = {}) {
+        return this.makeRequest("GET", "/unit", params);
+    }
+    async getUnit(unitId) {
+        return this.makeRequest("GET", `/unit/${unitId}`);
+    }
+    async createUnit(data) {
+        return this.makeRequest("POST", "/unit", undefined, data);
+    }
+    async deleteUnit(unitId) {
+        return this.makeRequest("DELETE", `/unit/${unitId}`);
+    }
+    // ===== COMPANY PROFILE =====
+    async getCompanyProfile() {
+        return this.makeRequest("GET", "/company_profile");
+    }
+    async updateCompanyProfile(data) {
+        return this.makeRequest("POST", "/company_profile", undefined, data);
+    }
+    // ===== PERMISSIONS =====
+    async listPermissions() {
+        return this.makeRequest("GET", "/permission");
+    }
+    // ===== PAYMENT TYPES =====
+    async listPaymentTypes(params = {}) {
+        return this.makeRequest("GET", "/payment_type", params);
+    }
+    async getPaymentType(paymentTypeId) {
+        return this.makeRequest("GET", `/payment_type/${paymentTypeId}`);
+    }
+    async createPaymentType(data) {
+        return this.makeRequest("POST", "/payment_type", undefined, data);
+    }
+    // ===== BANK ACCOUNTS (Read-Only) =====
+    async listBankAccounts(params = {}) {
+        return this.makeRequest("GET", "/bank_account", params);
+    }
+    async getBankAccount(accountId) {
+        return this.makeRequest("GET", `/bank_account/${accountId}`);
+    }
+    // ===== CURRENCIES =====
+    async listCurrencies(params = {}) {
+        return this.makeRequest("GET", "/currency", params);
+    }
+    async getCurrency(currencyId) {
+        return this.makeRequest("GET", `/currency/${currencyId}`);
+    }
+    async createCurrency(data) {
+        return this.makeRequest("POST", "/currency", undefined, data);
+    }
+    async updateCurrency(currencyId, data) {
+        return this.makeRequest("PATCH", `/currency/${currencyId}`, undefined, data);
+    }
+    async deleteCurrency(currencyId) {
+        return this.makeRequest("DELETE", `/currency/${currencyId}`);
+    }
+    // ===== IBAN PAYMENTS (Swiss ISO 20022) =====
+    async createIbanPayment(data) {
+        return this.makeRequest("POST", "/iban_payment", undefined, data);
+    }
+    async getIbanPayment(paymentId) {
+        return this.makeRequest("GET", `/iban_payment/${paymentId}`);
+    }
+    async updateIbanPayment(paymentId, data) {
+        return this.makeRequest("PATCH", `/iban_payment/${paymentId}`, undefined, data);
+    }
+    // ===== QR PAYMENTS (Swiss QR-invoice standard) =====
+    async createQrPayment(data) {
+        return this.makeRequest("POST", "/qr_payment", undefined, data);
+    }
+    async getQrPayment(paymentId) {
+        return this.makeRequest("GET", `/qr_payment/${paymentId}`);
+    }
+    async updateQrPayment(paymentId, data) {
+        return this.makeRequest("PATCH", `/qr_payment/${paymentId}`, undefined, data);
+    }
+    // ===== ORDERS =====
+    async listOrders(params = {}) {
+        return this.makeRequest("GET", "/kb_order", params);
+    }
+    async getOrder(orderId) {
+        return this.makeRequest("GET", `/kb_order/${orderId}`);
+    }
+    async createOrder(orderData) {
+        return this.makeRequest("POST", "/kb_order", undefined, orderData);
+    }
+    async searchOrders(searchParams) {
+        return this.makeRequest("POST", "/kb_order/search", undefined, searchParams);
+    }
+    async searchOrdersByContactId(contactId) {
+        const searchParams = [
+            { field: "contact_id", operator: "=", value: contactId.toString() },
+        ];
+        return this.makeRequest("POST", "/kb_order/search", undefined, searchParams);
+    }
+    async createDeliveryFromOrder(orderId) {
+        return this.makeRequest("POST", `/kb_order/${orderId}/create_delivery`);
+    }
+    async createInvoiceFromOrder(orderId) {
+        return this.makeRequest("POST", `/kb_order/${orderId}/create_invoice`);
+    }
+    // ===== CONTACTS =====
+    async listContacts(params = {}) {
+        const searchParams = {
+            limit: params.limit ?? 50,
+            offset: params.offset ?? 0,
+        };
+        if (params.search_term) {
+            searchParams["search"] = params.search_term;
+        }
+        if (params.contact_type_id) {
+            searchParams["contact_type_id"] = params.contact_type_id;
+        }
+        return this.makeRequest("GET", "/contact", searchParams);
+    }
+    async getContact(contactId) {
+        return this.makeRequest("GET", `/contact/${contactId}`);
+    }
+    async searchContacts(query, limit = 50) {
+        const searchCriteria = [
+            { field: "name_1", value: query, criteria: "like" },
+        ];
+        return this.advancedSearchContacts(searchCriteria, limit);
+    }
+    async advancedSearchContacts(searchCriteria, limit = 50) {
+        const params = { limit };
+        return this.makeRequest("POST", "/contact/search", params, searchCriteria);
+    }
+    async findContactByNumber(contactNumber) {
+        const searchCriteria = [
+            { field: "nr", value: contactNumber, criteria: "=" },
+        ];
+        const contacts = await this.advancedSearchContacts(searchCriteria, 1);
+        if (Array.isArray(contacts) && contacts.length > 0) {
+            return contacts[0];
+        }
+        throw McpError.notFound("Contact", contactNumber);
+    }
+    async findContactByName(name) {
+        const searchCriteria = [
+            { field: "name_1", value: name, criteria: "like" },
+        ];
+        return this.advancedSearchContacts(searchCriteria, 100);
+    }
+    async updateContact(contactId, contactData) {
+        return this.makeRequest("POST", `/contact/${contactId}`, undefined, contactData);
+    }
+    // ===== QUOTES =====
+    async createQuote(quoteData) {
+        return this.makeRequest("POST", "/kb_offer", undefined, quoteData);
+    }
+    async listQuotes(params = {}) {
+        return this.makeRequest("GET", "/kb_offer", params);
+    }
+    async getQuote(quoteId) {
+        return this.makeRequest("GET", `/kb_offer/${quoteId}`);
+    }
+    async searchQuotes(searchParams) {
+        return this.makeRequest("POST", "/kb_offer/search", undefined, searchParams);
+    }
+    async searchQuotesByContactId(contactId) {
+        const searchParams = [
+            { field: "contact_id", operator: "=", value: contactId.toString() },
+        ];
+        return this.makeRequest("POST", "/kb_offer/search", undefined, searchParams);
+    }
+    async issueQuote(quoteId) {
+        return this.makeRequest("POST", `/kb_offer/${quoteId}/issue`);
+    }
+    async acceptQuote(quoteId) {
+        return this.makeRequest("POST", `/kb_offer/${quoteId}/accept`);
+    }
+    async declineQuote(quoteId) {
+        return this.makeRequest("POST", `/kb_offer/${quoteId}/decline`);
+    }
+    async sendQuote(quoteId) {
+        return this.makeRequest("POST", `/kb_offer/${quoteId}/send`);
+    }
+    async createOrderFromQuote(quoteId) {
+        return this.makeRequest("POST", `/kb_offer/${quoteId}/create_order`);
+    }
+    async createInvoiceFromQuote(quoteId) {
+        return this.makeRequest("POST", `/kb_offer/${quoteId}/create_invoice`);
+    }
+    // ===== INVOICES =====
+    async listInvoices(params = {}) {
+        return this.makeRequest("GET", "/kb_invoice", params);
+    }
+    async getInvoice(invoiceId) {
+        return this.makeRequest("GET", `/kb_invoice/${invoiceId}`);
+    }
+    async createInvoice(invoiceData) {
+        // Set current date if not provided
+        if (!invoiceData.is_valid_from) {
+            invoiceData.is_valid_from = new Date().toISOString().split("T")[0];
+        }
+        return this.makeRequest("POST", "/kb_invoice", undefined, invoiceData);
+    }
+    async listAllInvoices(chunkSize = 100) {
+        if (chunkSize <= 0) {
+            throw McpError.validation("chunk_size must be positive");
+        }
+        const invoices = [];
+        let offset = 0;
+        while (offset < 10000) {
+            const batch = await this.listInvoices({ limit: chunkSize, offset });
+            if (!Array.isArray(batch) || batch.length === 0) {
+                break;
+            }
+            invoices.push(...batch);
+            if (batch.length < chunkSize) {
+                break;
+            }
+            offset += chunkSize;
+        }
+        return invoices;
+    }
+    async searchInvoices(params) {
+        const searchFilters = [];
+        if (params.filters) {
+            if (!Array.isArray(params.filters)) {
+                throw McpError.validation("filters must be a list of search expressions");
+            }
+            searchFilters.push(...params.filters);
+        }
+        if (params.query !== undefined) {
+            const op = params.operator?.toUpperCase() ?? "LIKE";
+            let value = params.query;
+            if (op === "LIKE" && !value.includes("%")) {
+                value = `%${params.query}%`;
+            }
+            searchFilters.push({
+                field: params.field ?? "title",
+                operator: op,
+                value: value,
+            });
+        }
+        if (searchFilters.length === 0) {
+            throw McpError.validation("Either query or filters must be provided");
+        }
+        const requestParams = params.limit ? { limit: params.limit } : undefined;
+        return this.makeRequest("POST", "/kb_invoice/search", requestParams, searchFilters);
+    }
+    async issueInvoice(invoiceId) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/issue`);
+    }
+    async cancelInvoice(invoiceId) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/cancel`);
+    }
+    async markInvoiceAsSent(invoiceId) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/mark_as_sent`);
+    }
+    async sendInvoice(invoiceId) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/send`);
+    }
+    async copyInvoice(invoiceId) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/copy`);
+    }
+    // ===== TAXES (3.0 API) =====
+    async listTaxes(params = {}) {
+        const response = await axios.get("https://api.bexio.com/3.0/taxes", {
+            headers: {
+                Authorization: `Bearer ${this.config.apiToken}`,
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+            params,
+        });
+        return response.data;
+    }
+    async getTax(taxId) {
+        const response = await axios.get(`https://api.bexio.com/3.0/taxes/${taxId}`, {
+            headers: {
+                Authorization: `Bearer ${this.config.apiToken}`,
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+        });
+        return response.data;
+    }
+    // ===== ITEMS (Articles) =====
+    async listItems(params = {}) {
+        return this.makeRequest("GET", "/article", params);
+    }
+    async getItem(itemId) {
+        return this.makeRequest("GET", `/article/${itemId}`);
+    }
+    async createItem(itemData) {
+        return this.makeRequest("POST", "/article", undefined, itemData);
+    }
+    // ===== DELIVERIES =====
+    async listDeliveries(params = {}) {
+        return this.makeRequest("GET", "/kb_delivery", params);
+    }
+    async getDelivery(deliveryId) {
+        return this.makeRequest("GET", `/kb_delivery/${deliveryId}`);
+    }
+    async issueDelivery(deliveryId) {
+        return this.makeRequest("POST", `/kb_delivery/${deliveryId}/issue`);
+    }
+    async searchDeliveries(searchParams) {
+        return this.makeRequest("POST", "/kb_delivery/search", undefined, searchParams);
+    }
+    // ===== PAYMENTS =====
+    async listPayments(invoiceId) {
+        return this.makeRequest("GET", `/kb_invoice/${invoiceId}/payment`);
+    }
+    async createPayment(invoiceId, paymentData) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/payment`, undefined, paymentData);
+    }
+    async getPayment(invoiceId, paymentId) {
+        return this.makeRequest("GET", `/kb_invoice/${invoiceId}/payment/${paymentId}`);
+    }
+    async deletePayment(invoiceId, paymentId) {
+        return this.makeRequest("DELETE", `/kb_invoice/${invoiceId}/payment/${paymentId}`);
+    }
+    // ===== REMINDERS =====
+    async listReminders(invoiceId) {
+        return this.makeRequest("GET", `/kb_invoice/${invoiceId}/reminder`);
+    }
+    async createReminder(invoiceId, reminderData) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/reminder`, undefined, reminderData);
+    }
+    async getReminder(invoiceId, reminderId) {
+        return this.makeRequest("GET", `/kb_invoice/${invoiceId}/reminder/${reminderId}`);
+    }
+    async deleteReminder(invoiceId, reminderId) {
+        return this.makeRequest("DELETE", `/kb_invoice/${invoiceId}/reminder/${reminderId}`);
+    }
+    async markReminderAsSent(invoiceId, reminderId) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/reminder/${reminderId}/mark_as_sent`);
+    }
+    async sendReminder(invoiceId, reminderId) {
+        return this.makeRequest("POST", `/kb_invoice/${invoiceId}/reminder/${reminderId}/send`);
+    }
+    // ===== CONTACT RELATIONS =====
+    async listContactRelations() {
+        return this.makeRequest("GET", "/contact_relation");
+    }
+    async createContactRelation(relationData) {
+        return this.makeRequest("POST", "/contact_relation", undefined, relationData);
+    }
+    async getContactRelation(relationId) {
+        return this.makeRequest("GET", `/contact_relation/${relationId}`);
+    }
+    async updateContactRelation(relationId, relationData) {
+        return this.makeRequest("POST", `/contact_relation/${relationId}`, undefined, relationData);
+    }
+    async deleteContactRelation(relationId) {
+        return this.makeRequest("DELETE", `/contact_relation/${relationId}`);
+    }
+    async searchContactRelations(searchParams) {
+        return this.makeRequest("POST", "/contact_relation/search", undefined, searchParams);
+    }
+    // ===== USERS =====
+    async getCurrentUser() {
+        return this.makeRequest("GET", "/user/me");
+    }
+    async listFictionalUsers(params = {}) {
+        return this.makeRequest("GET", "/fictional_user", params);
+    }
+    async getFictionalUser(userId) {
+        return this.makeRequest("GET", `/fictional_user/${userId}`);
+    }
+    async createFictionalUser(userData) {
+        return this.makeRequest("POST", "/fictional_user", undefined, userData);
+    }
+    async updateFictionalUser(userId, userData) {
+        return this.makeRequest("POST", `/fictional_user/${userId}`, undefined, userData);
+    }
+    async deleteFictionalUser(userId) {
+        return this.makeRequest("DELETE", `/fictional_user/${userId}`);
+    }
+    // ===== COMMENTS =====
+    async listComments() {
+        return this.makeRequest("GET", "/comment");
+    }
+    async getComment(commentId) {
+        return this.makeRequest("GET", `/comment/${commentId}`);
+    }
+    async createComment(commentData) {
+        return this.makeRequest("POST", "/comment", undefined, commentData);
+    }
+    // ===== SEARCH REMINDERS =====
+    async searchReminders(searchParams) {
+        // Search across all invoices to find reminders matching criteria
+        // This is a computed operation - get all recent invoices and their reminders
+        const invoices = await this.listAllInvoices(100);
+        const allReminders = [];
+        for (const invoice of invoices.slice(0, 50)) {
+            const invoiceId = invoice.id;
+            if (invoiceId) {
+                try {
+                    const reminders = await this.listReminders(invoiceId);
+                    allReminders.push(...reminders.map((r) => ({
+                        ...r,
+                        invoice_id: invoiceId,
+                    })));
+                }
+                catch {
+                    // Invoice may not have reminders, skip
+                }
+            }
+        }
+        return allReminders;
+    }
+    async getRemindersSentThisWeek() {
+        // Get reminders sent this week
+        const now = new Date();
+        const startOfWeek = new Date(now);
+        startOfWeek.setDate(now.getDate() - now.getDay());
+        startOfWeek.setHours(0, 0, 0, 0);
+        const allReminders = await this.searchReminders({});
+        return allReminders.filter((r) => {
+            const sentDate = r.sent_date;
+            if (!sentDate)
+                return false;
+            const date = new Date(sentDate);
+            return date >= startOfWeek;
+        });
+    }
+    // ===== REPORTS (Computed from invoice data) =====
+    async getRevenueReport(startDate, endDate, groupBy) {
+        // Compute revenue from paid invoices in date range
+        const invoices = await this.listAllInvoices(100);
+        const filteredInvoices = invoices.filter((inv) => {
+            const invoice = inv;
+            const invDate = invoice.is_valid_from;
+            // Status 9 = paid
+            const isPaid = invoice.kb_item_status_id === 9;
+            if (!invDate || !isPaid)
+                return false;
+            return invDate >= startDate && invDate <= endDate;
+        });
+        const totalRevenue = filteredInvoices.reduce((sum, inv) => {
+            const total = inv.total ?? 0;
+            return sum + total;
+        }, 0);
+        return {
+            start_date: startDate,
+            end_date: endDate,
+            total_revenue: totalRevenue,
+            invoice_count: filteredInvoices.length,
+            group_by: groupBy || null,
+        };
+    }
+    async getCustomerRevenueReport(startDate, endDate, limit = 10) {
+        const invoices = await this.listAllInvoices(100);
+        const customerRevenue = {};
+        invoices.forEach((inv) => {
+            const invoice = inv;
+            if (invoice.contact_id &&
+                invoice.is_valid_from &&
+                invoice.is_valid_from >= startDate &&
+                invoice.is_valid_from <= endDate &&
+                invoice.kb_item_status_id === 9) {
+                if (!customerRevenue[invoice.contact_id]) {
+                    customerRevenue[invoice.contact_id] = {
+                        contact_id: invoice.contact_id,
+                        total: 0,
+                        count: 0,
+                    };
+                }
+                customerRevenue[invoice.contact_id].total += invoice.total ?? 0;
+                customerRevenue[invoice.contact_id].count += 1;
+            }
+        });
+        return Object.values(customerRevenue)
+            .sort((a, b) => b.total - a.total)
+            .slice(0, limit);
+    }
+    async getInvoiceStatusReport(startDate, endDate) {
+        const invoices = await this.listAllInvoices(100);
+        const statusCounts = {};
+        invoices.forEach((inv) => {
+            const invoice = inv;
+            if (invoice.is_valid_from &&
+                invoice.is_valid_from >= startDate &&
+                invoice.is_valid_from <= endDate &&
+                invoice.kb_item_status_id) {
+                statusCounts[invoice.kb_item_status_id] =
+                    (statusCounts[invoice.kb_item_status_id] || 0) + 1;
+            }
+        });
+        return {
+            start_date: startDate,
+            end_date: endDate,
+            status_counts: statusCounts,
+        };
+    }
+    async getOverdueInvoicesReport() {
+        return this.getOverdueInvoices();
+    }
+    async getMonthlyRevenueReport(year, month) {
+        const startDate = `${year}-${String(month).padStart(2, "0")}-01`;
+        const lastDay = new Date(year, month, 0).getDate();
+        const endDate = `${year}-${String(month).padStart(2, "0")}-${lastDay}`;
+        return this.getRevenueReport(startDate, endDate);
+    }
+    async getTopCustomersByRevenue(limit = 10, startDate, endDate) {
+        const start = startDate || "2000-01-01";
+        const end = endDate || new Date().toISOString().split("T")[0];
+        return this.getCustomerRevenueReport(start, end, limit);
+    }
+    // ===== BUSINESS LOGIC =====
+    async getOpenInvoices() {
+        // Status 7 = Draft/Open, Status 8 = Sent/Pending
+        const invoices = await this.listAllInvoices(100);
+        return invoices.filter((inv) => {
+            const statusId = inv.kb_item_status_id;
+            return statusId === 7 || statusId === 8;
+        });
+    }
+    async getOverdueInvoices() {
+        const today = new Date().toISOString().split("T")[0];
+        const invoices = await this.listAllInvoices(100);
+        return invoices.filter((inv) => {
+            const invoice = inv;
+            // Status 8 = Sent but not paid, and due date passed
+            return (invoice.kb_item_status_id === 8 &&
+                invoice.is_valid_until &&
+                invoice.is_valid_until < today);
+        });
+    }
+    async getTasksDueThisWeek() {
+        const now = new Date();
+        const endOfWeek = new Date(now);
+        endOfWeek.setDate(now.getDate() + (6 - now.getDay()));
+        const today = now.toISOString().split("T")[0];
+        const weekEnd = endOfWeek.toISOString().split("T")[0];
+        const invoices = await this.listAllInvoices(100);
+        return invoices.filter((inv) => {
+            const invoice = inv;
+            // Open or sent invoices with due date this week
+            const isOpen = invoice.kb_item_status_id === 7 || invoice.kb_item_status_id === 8;
+            const dueDate = invoice.is_valid_until;
+            return isOpen && dueDate && dueDate >= today && dueDate <= weekEnd;
+        });
+    }
+    // ===== STATIC DATA =====
+    async listInvoiceStatuses() {
+        return [
+            {
+                id: 7,
+                name: "Entwurf/Offen",
+                english_name: "Draft/Open",
+                is_open: true,
+                is_sent: false,
+                is_paid: false,
+                is_cancelled: false,
+            },
+            {
+                id: 8,
+                name: "Versendet/Ausstehend",
+                english_name: "Sent/Pending",
+                is_open: false,
+                is_sent: true,
+                is_paid: false,
+                is_cancelled: false,
+            },
+            {
+                id: 9,
+                name: "Bezahlt/Abgeschlossen",
+                english_name: "Paid/Completed",
+                is_open: false,
+                is_sent: true,
+                is_paid: true,
+                is_cancelled: false,
+            },
+            {
+                id: 19,
+                name: "Storniert",
+                english_name: "Cancelled",
+                is_open: false,
+                is_sent: false,
+                is_paid: false,
+                is_cancelled: true,
+            },
+        ];
+    }
+    async listAllStatuses(documentType = "all") {
+        const statuses = {
+            invoices: await this.listInvoiceStatuses(),
+            quotes: [
+                { id: 1, name: "Entwurf", english_name: "Draft", document_type: "quote" },
+                { id: 3, name: "Versendet", english_name: "Sent", document_type: "quote" },
+            ],
+            orders: [
+                {
+                    id: 5,
+                    name: "Bestatigt",
+                    english_name: "Confirmed",
+                    document_type: "order",
+                },
+                {
+                    id: 21,
+                    name: "Wiederkehrend",
+                    english_name: "Recurring",
+                    document_type: "order",
+                },
+            ],
+        };
+        if (documentType === "all") {
+            return [...statuses.invoices, ...statuses.quotes, ...statuses.orders];
+        }
+        return statuses[documentType] || [];
+    }
+    // ===== PROJECTS =====
+    async listProjects(params = {}) {
+        return this.makeRequest("GET", "/pr_project", params);
+    }
+    async getProject(projectId) {
+        return this.makeRequest("GET", `/pr_project/${projectId}`);
+    }
+    async createProject(data) {
+        return this.makeRequest("POST", "/pr_project", undefined, data);
+    }
+    async updateProject(projectId, data) {
+        return this.makeRequest("POST", `/pr_project/${projectId}`, undefined, data);
+    }
+    async deleteProject(projectId) {
+        return this.makeRequest("DELETE", `/pr_project/${projectId}`);
+    }
+    async archiveProject(projectId) {
+        return this.makeRequest("POST", `/pr_project/${projectId}/archive`);
+    }
+    async unarchiveProject(projectId) {
+        return this.makeRequest("POST", `/pr_project/${projectId}/unarchive`);
+    }
+    async searchProjects(searchParams) {
+        return this.makeRequest("POST", "/pr_project/search", undefined, searchParams);
+    }
+    // ===== PROJECT TYPES =====
+    async listProjectTypes(params = {}) {
+        return this.makeRequest("GET", "/pr_project_type", params);
+    }
+    async getProjectType(typeId) {
+        return this.makeRequest("GET", `/pr_project_type/${typeId}`);
+    }
+    // ===== PROJECT STATUSES =====
+    async listProjectStatuses(params = {}) {
+        return this.makeRequest("GET", "/pr_project_state", params);
+    }
+    async getProjectStatus(statusId) {
+        return this.makeRequest("GET", `/pr_project_state/${statusId}`);
+    }
+    // ===== MILESTONES (PROJ-04) =====
+    async listMilestones(projectId, params = {}) {
+        return this.makeRequest("GET", `/pr_project/${projectId}/milestone`, params);
+    }
+    async getMilestone(projectId, milestoneId) {
+        return this.makeRequest("GET", `/pr_project/${projectId}/milestone/${milestoneId}`);
+    }
+    async createMilestone(projectId, data) {
+        return this.makeRequest("POST", `/pr_project/${projectId}/milestone`, undefined, data);
+    }
+    async deleteMilestone(projectId, milestoneId) {
+        return this.makeRequest("DELETE", `/pr_project/${projectId}/milestone/${milestoneId}`);
+    }
+    // ===== WORK PACKAGES (PROJ-05) =====
+    async listWorkPackages(projectId, params = {}) {
+        return this.makeRequest("GET", `/pr_project/${projectId}/workpackage`, params);
+    }
+    async getWorkPackage(projectId, workpackageId) {
+        return this.makeRequest("GET", `/pr_project/${projectId}/workpackage/${workpackageId}`);
+    }
+    async createWorkPackage(projectId, data) {
+        return this.makeRequest("POST", `/pr_project/${projectId}/workpackage`, undefined, data);
+    }
+    async updateWorkPackage(projectId, workpackageId, data) {
+        return this.makeRequest("PATCH", `/pr_project/${projectId}/workpackage/${workpackageId}`, undefined, data);
+    }
+    async deleteWorkPackage(projectId, workpackageId) {
+        return this.makeRequest("DELETE", `/pr_project/${projectId}/workpackage/${workpackageId}`);
+    }
+    // ===== TIMESHEETS (PROJ-06) =====
+    // Note: Duration format is "HH:MM" (e.g., "02:30" for 2.5 hours)
+    async listTimesheets(params = {}) {
+        return this.makeRequest("GET", "/timesheet", params);
+    }
+    async getTimesheet(timesheetId) {
+        return this.makeRequest("GET", `/timesheet/${timesheetId}`);
+    }
+    async createTimesheet(data) {
+        return this.makeRequest("POST", "/timesheet", undefined, data);
+    }
+    async deleteTimesheet(timesheetId) {
+        return this.makeRequest("DELETE", `/timesheet/${timesheetId}`);
+    }
+    async searchTimesheets(searchParams) {
+        return this.makeRequest("POST", "/timesheet/search", undefined, searchParams);
+    }
+    // ===== TIMESHEET STATUSES (PROJ-07) =====
+    async listTimesheetStatuses() {
+        return this.makeRequest("GET", "/timesheet_status");
+    }
+    // ===== BUSINESS ACTIVITIES (PROJ-08) =====
+    // Also known as "client_service" in Bexio API
+    async listBusinessActivities(params = {}) {
+        return this.makeRequest("GET", "/client_service", params);
+    }
+    async getBusinessActivity(activityId) {
+        return this.makeRequest("GET", `/client_service/${activityId}`);
+    }
+    async createBusinessActivity(data) {
+        return this.makeRequest("POST", "/client_service", undefined, data);
+    }
+    // ===== COMMUNICATION TYPES (PROJ-09) =====
+    async listCommunicationTypes(params = {}) {
+        return this.makeRequest("GET", "/communication_kind", params);
+    }
+    async getCommunicationType(typeId) {
+        return this.makeRequest("GET", `/communication_kind/${typeId}`);
+    }
+    // ===== ACCOUNTS (Chart of Accounts - ACCT-01) =====
+    async listAccounts(params = {}) {
+        return this.makeRequest("GET", "/accounts", params);
+    }
+    async getAccount(accountId) {
+        return this.makeRequest("GET", `/accounts/${accountId}`);
+    }
+    async createAccount(data) {
+        return this.makeRequest("POST", "/accounts", undefined, data);
+    }
+    async searchAccounts(searchParams) {
+        return this.makeRequest("POST", "/accounts/search", undefined, searchParams);
+    }
+    // ===== ACCOUNT GROUPS (ACCT-02) =====
+    async listAccountGroups(params = {}) {
+        return this.makeRequest("GET", "/account_groups", params);
+    }
+    // ===== CALENDAR YEARS (ACCT-03) =====
+    async listCalendarYears(params = {}) {
+        return this.makeRequest("GET", "/calendar_year", params);
+    }
+    async getCalendarYear(yearId) {
+        return this.makeRequest("GET", `/calendar_year/${yearId}`);
+    }
+    // ===== BUSINESS YEARS (ACCT-04) =====
+    async listBusinessYears(params = {}) {
+        return this.makeRequest("GET", "/business_year", params);
+    }
+    // ===== MANUAL ENTRIES (ACCT-05) =====
+    async listManualEntries(params = {}) {
+        return this.makeRequest("GET", "/manual_entry", params);
+    }
+    async getManualEntry(entryId) {
+        return this.makeRequest("GET", `/manual_entry/${entryId}`);
+    }
+    async createManualEntry(data) {
+        return this.makeRequest("POST", "/manual_entry", undefined, data);
+    }
+    async updateManualEntry(entryId, data) {
+        return this.makeRequest("PUT", `/manual_entry/${entryId}`, undefined, data);
+    }
+    async deleteManualEntry(entryId) {
+        return this.makeRequest("DELETE", `/manual_entry/${entryId}`);
+    }
+    // ===== VAT PERIODS (ACCT-06) =====
+    async listVatPeriods(params = {}) {
+        return this.makeRequest("GET", "/vat_period", params);
+    }
+    // ===== ACCOUNTING JOURNAL (ACCT-07) =====
+    async getJournal(params) {
+        return this.makeRequest("GET", "/journal", params);
+    }
+    // ===== BILLS (Creditor Invoices - PURCH-01) =====
+    async listBills(params = {}) {
+        return this.makeRequest("GET", "/kb_bill", params);
+    }
+    async getBill(billId) {
+        return this.makeRequest("GET", `/kb_bill/${billId}`);
+    }
+    async createBill(data) {
+        return this.makeRequest("POST", "/kb_bill", undefined, data);
+    }
+    async updateBill(billId, data) {
+        return this.makeRequest("POST", `/kb_bill/${billId}`, undefined, data);
+    }
+    async deleteBill(billId) {
+        return this.makeRequest("DELETE", `/kb_bill/${billId}`);
+    }
+    async searchBills(searchParams, queryParams) {
+        return this.makeRequest("POST", "/kb_bill/search", queryParams, searchParams);
+    }
+    async issueBill(billId) {
+        return this.makeRequest("POST", `/kb_bill/${billId}/issue`);
+    }
+    async markBillAsPaid(billId) {
+        return this.makeRequest("POST", `/kb_bill/${billId}/mark_as_paid`);
+    }
+    // ===== EXPENSES (PURCH-02) =====
+    async listExpenses(params = {}) {
+        return this.makeRequest("GET", "/kb_expense", params);
+    }
+    async getExpense(expenseId) {
+        return this.makeRequest("GET", `/kb_expense/${expenseId}`);
+    }
+    async createExpense(data) {
+        return this.makeRequest("POST", "/kb_expense", undefined, data);
+    }
+    async updateExpense(expenseId, data) {
+        return this.makeRequest("POST", `/kb_expense/${expenseId}`, undefined, data);
+    }
+    async deleteExpense(expenseId) {
+        return this.makeRequest("DELETE", `/kb_expense/${expenseId}`);
+    }
+    // ===== PURCHASE ORDERS (PURCH-03) =====
+    async listPurchaseOrders(params = {}) {
+        return this.makeRequest("GET", "/purchase_order", params);
+    }
+    async getPurchaseOrder(purchaseOrderId) {
+        return this.makeRequest("GET", `/purchase_order/${purchaseOrderId}`);
+    }
+    async createPurchaseOrder(data) {
+        return this.makeRequest("POST", "/purchase_order", undefined, data);
+    }
+    async updatePurchaseOrder(purchaseOrderId, data) {
+        return this.makeRequest("POST", `/purchase_order/${purchaseOrderId}`, undefined, data);
+    }
+    async deletePurchaseOrder(purchaseOrderId) {
+        return this.makeRequest("DELETE", `/purchase_order/${purchaseOrderId}`);
+    }
+    // ===== OUTGOING PAYMENTS (linked to bills - PURCH-04) =====
+    // Note: Uses nested URL pattern /kb_bill/{id}/payment (mirrors incoming payments on invoices)
+    async listOutgoingPayments(billId) {
+        return this.makeRequest("GET", `/kb_bill/${billId}/payment`);
+    }
+    async getOutgoingPayment(billId, paymentId) {
+        return this.makeRequest("GET", `/kb_bill/${billId}/payment/${paymentId}`);
+    }
+    async createOutgoingPayment(billId, paymentData) {
+        return this.makeRequest("POST", `/kb_bill/${billId}/payment`, undefined, paymentData);
+    }
+    async updateOutgoingPayment(billId, paymentId, paymentData) {
+        return this.makeRequest("POST", `/kb_bill/${billId}/payment/${paymentId}`, undefined, paymentData);
+    }
+    async deleteOutgoingPayment(billId, paymentId) {
+        return this.makeRequest("DELETE", `/kb_bill/${billId}/payment/${paymentId}`);
+    }
+    // ===== EMPLOYEES (PAY-01) =====
+    // Note: Payroll module may not be enabled - handlers check availability
+    async listEmployees(params = {}) {
+        return this.makeRequest("GET", "/employee", params);
+    }
+    async getEmployee(employeeId) {
+        return this.makeRequest("GET", `/employee/${employeeId}`);
+    }
+    async createEmployee(data) {
+        return this.makeRequest("POST", "/employee", undefined, data);
+    }
+    async updateEmployee(employeeId, data) {
+        return this.makeRequest("POST", `/employee/${employeeId}`, undefined, data);
+    }
+    // ===== ABSENCES (PAY-02) =====
+    async listAbsences(params = {}) {
+        return this.makeRequest("GET", "/absence", params);
+    }
+    async getAbsence(absenceId) {
+        return this.makeRequest("GET", `/absence/${absenceId}`);
+    }
+    async createAbsence(data) {
+        return this.makeRequest("POST", "/absence", undefined, data);
+    }
+    async updateAbsence(absenceId, data) {
+        return this.makeRequest("POST", `/absence/${absenceId}`, undefined, data);
+    }
+    async deleteAbsence(absenceId) {
+        return this.makeRequest("DELETE", `/absence/${absenceId}`);
+    }
+    // ===== PAYROLL DOCUMENTS (PAY-03) =====
+    async listPayrollDocuments(params = {}) {
+        return this.makeRequest("GET", "/payroll_document", params);
+    }
+    // ===== FILES (FILE-01) =====
+    async listFiles(params = {}) {
+        return this.makeRequest("GET", "/file", params);
+    }
+    async getFile(fileId) {
+        return this.makeRequest("GET", `/file/${fileId}`);
+    }
+    async uploadFile(data) {
+        const buffer = Buffer.from(data.content_base64, "base64");
+        // Use form-data for multipart upload (transitive dep of axios)
+        const FormData = (await import("form-data")).default;
+        const formData = new FormData();
+        formData.append("file", buffer, {
+            filename: data.name,
+            contentType: data.content_type,
+        });
+        return this.client.post("/file", formData, {
+            headers: formData.getHeaders(),
+        }).then(r => r.data);
+    }
+    async downloadFile(fileId) {
+        const response = await this.client.get(`/file/${fileId}/download`, {
+            responseType: "arraybuffer",
+        });
+        return Buffer.from(response.data).toString("base64");
+    }
+    async updateFile(fileId, data) {
+        return this.makeRequest("POST", `/file/${fileId}`, undefined, data);
+    }
+    async deleteFile(fileId) {
+        return this.makeRequest("DELETE", `/file/${fileId}`);
+    }
+    // ===== ADDITIONAL ADDRESSES (FILE-02) =====
+    async listAdditionalAddresses(contactId, params = {}) {
+        return this.makeRequest("GET", `/contact/${contactId}/additional_address`, params);
+    }
+    async getAdditionalAddress(contactId, addressId) {
+        return this.makeRequest("GET", `/contact/${contactId}/additional_address/${addressId}`);
+    }
+    async createAdditionalAddress(contactId, data) {
+        return this.makeRequest("POST", `/contact/${contactId}/additional_address`, undefined, data);
+    }
+    async deleteAdditionalAddress(contactId, addressId) {
+        return this.makeRequest("DELETE", `/contact/${contactId}/additional_address/${addressId}`);
+    }
+}