buchpilot-mcp 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
+Versioning: [Semantic Versioning](https://semver.org/)
+
+## [0.1.1] - 2026-03-19 11:30
+
+### Fixed
+- Email-Mapping fuer Person-Kontakte: Email wird jetzt korrekt in Lexoffice gesetzt und gelesen
+- Rate-Limiter fuer PDF-Download: `getInvoicePdf` nutzt jetzt Rate-Limiting + Fehlerbehandlung
+- `contactId`-Filter in `listInvoices` wird jetzt korrekt an Lexoffice API uebergeben
+- PDF-Response nutzt Standard-Text-Format statt fragwuerdigem `resource`-Typ
+- CHANGELOG: "Sync" korrigiert zu "Ueberfaellige Rechnungen"
+
+## [0.1.0] - 2026-03-18 10:00
+
+### Added
+- MCP Server fuer DACH-Buchhaltung via Model Context Protocol (stdio Transport)
+- Backend-Architektur mit austauschbaren Backends (aktuell: Lexoffice)
+- Lexoffice-Backend: vollstaendige API-Integration mit Lazy-Initialisierung
+- Tools: Kontakte (create, get, list, update)
+- Tools: Rechnungen (create, get, list, get_pdf, update)
+- Tools: Belege/Vouchers (create, get, list)
+- Tools: Angebote/Quotations (create, get)
+- Tools: Ueberfaellige Rechnungen (get_overdue_invoices)
+- Konfiguration via Umgebungsvariablen/Config-Datei
+- Strukturierte Fehlerbehandlung mit Error Codes
+- Zod-basierte Input-Validierung fuer alle Tools
+- TypeScript mit ES Modules

package/README.md

@@ -0,0 +1,198 @@
+# BuchPilot MCP Server
+
+> MCP Server fuer DACH-Buchhaltung — Kontakte, Rechnungen, Belege und Angebote direkt aus Claude, Cursor oder jedem MCP-kompatiblen Client verwalten.
+
+[![npm version](https://img.shields.io/npm/v/buchpilot-mcp.svg)](https://www.npmjs.com/package/buchpilot-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+## Was ist das?
+
+BuchPilot MCP ist ein [Model Context Protocol](https://modelcontextprotocol.io/) Server, der dein Buchhaltungssystem (aktuell Lexoffice) mit KI-Assistenten verbindet. Du kannst per natuerlicher Sprache Rechnungen erstellen, Kontakte verwalten und ueberfaellige Zahlungen pruefen — direkt in Claude Desktop, Cursor oder jedem anderen MCP-Client.
+
+## Features
+
+- **15 Tools** fuer vollstaendige Buchhaltungs-Automatisierung
+- **Kontakte** erstellen, abrufen, auflisten, aktualisieren
+- **Rechnungen** erstellen, abrufen, auflisten, aktualisieren, PDF herunterladen
+- **Belege** erstellen, abrufen, auflisten (Eingangsrechnungen, Gutschriften)
+- **Angebote** erstellen, abrufen
+- **Ueberfaellige Rechnungen** mit Betraegen und Tagen ueberfaellig
+- **Backend-Architektur** — aktuell Lexoffice, erweiterbar fuer sevDesk, Billomat etc.
+- **Plugin-faehig** — kann E-Invoice MCP Tools integrieren (`einvoice-mcp`)
+- Keine Datenbank, kein State — reiner API-Proxy
+
+## Installation
+
+### Voraussetzungen
+
+- Node.js >= 18
+- Ein [Lexoffice](https://www.lexoffice.de/)-Account mit API-Key
+
+### npm (global)
+
+```bash
+npm install -g buchpilot-mcp
+```
+
+### Von Source
+
+```bash
+git clone https://github.com/makririch/buchpilot-mcp.git
+cd buchpilot-mcp
+npm install
+npm run build
+```
+
+## Konfiguration
+
+Erstelle eine Konfigurationsdatei `.buchpilot.json` an einem der folgenden Orte:
+
+1. Pfad aus Umgebungsvariable `BUCHPILOT_CONFIG`
+2. `~/.buchpilot.json` (Home-Verzeichnis)
+3. `./.buchpilot.json` (aktuelles Verzeichnis)
+
+### Inhalt der .buchpilot.json
+
+```json
+{
+  "backends": {
+    "lexoffice": {
+      "api_key": "DEIN_LEXOFFICE_API_KEY"
+    }
+  },
+  "default_backend": "lexoffice"
+}
+```
+
+### Lexoffice API-Key erstellen
+
+1. Gehe zu [Lexoffice Public API](https://app.lexoffice.de/addons/public-api)
+2. Klicke auf **API-Key erstellen**
+3. Kopiere den Key und fuege ihn in `.buchpilot.json` ein
+
+> **Sicherheitshinweis:** Speichere den API-Key nie in Git. Fuege `.buchpilot.json` zu deiner `.gitignore` hinzu.
+
+## Nutzung
+
+### Server starten (standalone)
+
+```bash
+# Nach npm install -g:
+buchpilot-mcp
+
+# Oder von Source:
+npm start
+
+# Entwicklung mit Auto-Reload:
+npm run dev
+```
+
+Der Server laeuft ueber stdio und wartet auf MCP-Nachrichten.
+
+### In Claude Desktop verwenden
+
+Siehe [Claude Desktop Setup Guide](docs/claude-desktop-setup.md) fuer eine detaillierte Anleitung.
+
+Kurzversion — fuege in `claude_desktop_config.json` hinzu:
+
+```json
+{
+  "mcpServers": {
+    "buchpilot": {
+      "command": "npx",
+      "args": ["-y", "buchpilot-mcp"],
+      "env": {
+        "BUCHPILOT_CONFIG": "/Users/DEIN_NAME/.buchpilot.json"
+      }
+    }
+  }
+}
+```
+
+### Beispiele (natuerliche Sprache in Claude)
+
+Nachdem du den Server konfiguriert hast, kannst du Claude z.B. fragen:
+
+- "Erstelle einen Kontakt fuer die Firma Beispiel GmbH mit der E-Mail info@beispiel.de"
+- "Zeige mir alle offenen Rechnungen"
+- "Erstelle eine Rechnung an Kontakt XYZ: 10 Stunden Beratung zu je 150 EUR"
+- "Welche Rechnungen sind ueberfaellig?"
+- "Lade die PDF von Rechnung ABC herunter"
+- "Erstelle ein Angebot fuer 5 Lizenzen a 49 EUR/Monat"
+
+## Tool-Referenz
+
+Eine vollstaendige Referenz aller 15 Tools mit Parametern, Beispiel-Inputs und Beispiel-Outputs findest du in [docs/tool-reference.md](docs/tool-reference.md).
+
+### Kurzuebersicht
+
+| Tool | Beschreibung |
+|------|-------------|
+| `create_contact` | Neuen Kontakt anlegen (Person oder Firma) |
+| `get_contact` | Kontakt per ID abrufen |
+| `list_contacts` | Kontakte auflisten mit Filtern |
+| `update_contact` | Kontakt aktualisieren |
+| `create_invoice` | Neue Rechnung mit Positionen erstellen |
+| `get_invoice` | Rechnung per ID abrufen |
+| `list_invoices` | Rechnungen auflisten (nach Status filterbar) |
+| `get_invoice_pdf` | Rechnung als PDF herunterladen (Base64) |
+| `update_invoice` | Entwurfs-Rechnung aktualisieren |
+| `create_voucher` | Neuen Beleg anlegen |
+| `get_voucher` | Beleg per ID abrufen |
+| `list_vouchers` | Belege auflisten |
+| `create_quotation` | Neues Angebot mit Positionen erstellen |
+| `get_quotation` | Angebot per ID abrufen |
+| `get_overdue_invoices` | Ueberfaellige Rechnungen mit Analyse |
+
+## E-Invoice Integration
+
+BuchPilot MCP kann optional das [E-Invoice MCP](https://www.npmjs.com/package/einvoice-mcp) Paket integrieren, um XRechnung und ZUGFeRD direkt aus dem Buchhaltungssystem zu erzeugen:
+
+```typescript
+// In deinem eigenen MCP-Server:
+import { registerEInvoiceTools } from "einvoice-mcp";
+registerEInvoiceTools(server);
+// Ergebnis: 15 + 4 = 19 Tools
+```
+
+## FAQ / Troubleshooting
+
+### "No .buchpilot.json found"
+
+Der Server findet keine Konfigurationsdatei. Erstelle eine `.buchpilot.json` in deinem Home-Verzeichnis:
+
+```bash
+echo '{"backends":{"lexoffice":{"api_key":"DEIN_KEY"}},"default_backend":"lexoffice"}' > ~/.buchpilot.json
+```
+
+### "401 Unauthorized" bei Lexoffice
+
+- Ist der API-Key korrekt in `.dachflow.json`?
+- Ist der Key noch aktiv? Pruefe unter [Lexoffice Public API](https://app.lexoffice.de/addons/public-api)
+- API-Keys koennen ablaufen — erstelle ggf. einen neuen
+
+### "429 Too Many Requests"
+
+Lexoffice erlaubt max. 2 Requests pro Sekunde. Wenn du viele Operationen hintereinander ausfuehrst, warte kurz zwischen den Anfragen.
+
+### Server startet, aber Claude erkennt die Tools nicht
+
+- Pruefe ob die `claude_desktop_config.json` korrekt ist
+- Starte Claude Desktop neu nach Konfigurationsaenderungen
+- Pruefe die Logs: `~/Library/Logs/Claude/mcp.log` (macOS)
+
+### Rechnung kann nicht aktualisiert werden
+
+Nur Rechnungen im Status **draft** (Entwurf) koennen aktualisiert werden. Finalisierte Rechnungen sind unveraenderlich.
+
+### Backend "sevDesk" nicht verfuegbar
+
+Aktuell wird nur **Lexoffice** als Backend unterstuetzt. sevDesk-Unterstuetzung ist geplant. Du kannst die n8n-Nodes (`n8n-nodes-buchpilot`) fuer sevDesk verwenden.
+
+## Lizenz
+
+MIT — Frei nutzbar, auch kommerziell.
+
+## Autor
+
+**MaKri** — [GitHub](https://github.com/makririch/buchpilot-mcp)

package/dist/backends/lexoffice.d.ts

@@ -0,0 +1,23 @@
+import type { IAccountingBackend, Contact, ContactInput, ContactFilter, Invoice, InvoiceInput, InvoiceFilter, Voucher, VoucherInput, VoucherFilter, Quotation, QuotationInput } from "./types.js";
+export declare class LexofficeBackend implements IAccountingBackend {
+    name: string;
+    private apiKey;
+    constructor(apiKey: string);
+    createContact(input: ContactInput): Promise<Contact>;
+    getContact(id: string): Promise<Contact>;
+    listContacts(filter?: ContactFilter): Promise<Contact[]>;
+    updateContact(id: string, input: Partial<ContactInput>): Promise<Contact>;
+    createInvoice(input: InvoiceInput): Promise<Invoice>;
+    getInvoice(id: string): Promise<Invoice>;
+    listInvoices(filter?: InvoiceFilter): Promise<Invoice[]>;
+    getInvoicePdf(id: string): Promise<{
+        data: Buffer;
+        filename: string;
+    }>;
+    updateInvoice(id: string, input: Partial<InvoiceInput>): Promise<Invoice>;
+    createVoucher(input: VoucherInput): Promise<Voucher>;
+    getVoucher(id: string): Promise<Voucher>;
+    listVouchers(filter?: VoucherFilter): Promise<Voucher[]>;
+    createQuotation(input: QuotationInput): Promise<Quotation>;
+    getQuotation(id: string): Promise<Quotation>;
+}

package/dist/backends/lexoffice.js

@@ -0,0 +1,344 @@
+import { ErrorCode, createError } from "../errors.js";
+const BASE_URL = "https://api.lexoffice.io/v1";
+// Rate limiter: Lexoffice allows max 2 requests/second
+let lastRequestTime = 0;
+async function rateLimitSleep() {
+    const now = Date.now();
+    const elapsed = now - lastRequestTime;
+    if (elapsed < 500) {
+        await new Promise((resolve) => setTimeout(resolve, 500 - elapsed));
+    }
+    lastRequestTime = Date.now();
+}
+async function lexofficeRequest(apiKey, method, endpoint, body, qs) {
+    await rateLimitSleep();
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [key, value] of Object.entries(qs)) {
+            url.searchParams.set(key, value);
+        }
+    }
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+    };
+    const options = { method, headers };
+    if (body && method !== "GET") {
+        headers["Content-Type"] = "application/json";
+        options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url.toString(), options);
+    if (response.status === 401) {
+        throw createError(ErrorCode.AUTH_FAILED, "Lexoffice API key is invalid or expired");
+    }
+    if (response.status === 429) {
+        throw createError(ErrorCode.RATE_LIMITED, "Lexoffice API rate limit exceeded (max 2 req/s)");
+    }
+    if (response.status === 404) {
+        throw createError(ErrorCode.NOT_FOUND, `Resource not found: ${endpoint}`);
+    }
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        throw createError(ErrorCode.BACKEND_ERROR, `Lexoffice API error ${response.status}: ${errorText}`);
+    }
+    if (response.status === 204)
+        return {};
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+        return response.json();
+    }
+    return response;
+}
+// === Mapping Helpers ===
+function toLexofficeContact(input) {
+    const roles = {};
+    const role = input.role || "customer";
+    if (role === "customer" || role === "both")
+        roles.customer = {};
+    if (role === "vendor" || role === "both")
+        roles.vendor = {};
+    const body = { version: 0, roles };
+    if (input.type === "company") {
+        body.company = {
+            name: input.name,
+            ...(input.email ? { contactPersons: [{ emailAddress: input.email }] } : {}),
+        };
+    }
+    else {
+        body.person = {
+            lastName: input.name,
+            ...(input.firstName ? { firstName: input.firstName } : {}),
+        };
+        if (input.email) {
+            body.emailAddresses = { business: [input.email] };
+        }
+    }
+    return body;
+}
+function fromLexofficeContact(raw) {
+    const isCompany = !!raw.company;
+    return {
+        id: raw.id,
+        type: isCompany ? "company" : "person",
+        name: isCompany ? raw.company?.name : raw.person?.lastName,
+        firstName: raw.person?.firstName,
+        email: isCompany
+            ? raw.company?.contactPersons?.[0]?.emailAddress
+            : raw.emailAddresses?.business?.[0] || raw.emailAddresses?.private?.[0],
+        role: raw.roles?.customer && raw.roles?.vendor
+            ? "both"
+            : raw.roles?.vendor ? "vendor" : "customer",
+        backend: "lexoffice",
+        raw,
+    };
+}
+function toLexofficeInvoice(input) {
+    return {
+        voucherDate: input.date,
+        address: { contactId: input.contactId },
+        lineItems: input.lineItems.map((item) => ({
+            type: "custom",
+            name: item.name,
+            quantity: item.quantity,
+            unitName: "Stueck",
+            unitPrice: {
+                currency: input.currency || "EUR",
+                netAmount: item.unitPrice,
+                taxRatePercentage: item.taxRate,
+            },
+        })),
+        totalPrice: { currency: input.currency || "EUR" },
+        taxConditions: { taxType: "net" },
+        ...(input.title && { title: input.title }),
+        ...(input.introduction && { introduction: input.introduction }),
+        ...(input.remark && { remark: input.remark }),
+    };
+}
+function fromLexofficeInvoice(raw) {
+    const lineItems = (raw.lineItems || [])
+        .filter((li) => li.type === "custom")
+        .map((li) => ({
+        name: li.name,
+        quantity: li.quantity,
+        unitPrice: li.unitPrice?.netAmount || 0,
+        taxRate: li.unitPrice?.taxRatePercentage || 0,
+    }));
+    return {
+        id: raw.id,
+        number: raw.voucherNumber || "",
+        contactId: raw.address?.contactId || "",
+        date: raw.voucherDate || "",
+        dueDate: raw.dueDate || raw.voucherDate || "",
+        status: raw.voucherStatus === "draft" ? "draft"
+            : raw.voucherStatus === "open" ? "open"
+                : raw.voucherStatus === "paid" ? "paid"
+                    : raw.voucherStatus === "overdue" ? "overdue"
+                        : "open",
+        totalNet: raw.totalPrice?.totalNetAmount || 0,
+        totalGross: raw.totalPrice?.totalGrossAmount || 0,
+        currency: raw.totalPrice?.currency || "EUR",
+        lineItems,
+        backend: "lexoffice",
+        raw,
+    };
+}
+function fromLexofficeVoucher(raw) {
+    return {
+        id: raw.id,
+        type: raw.voucherType || "",
+        date: raw.voucherDate || "",
+        totalGross: raw.totalGrossAmount || 0,
+        taxRate: raw.voucherItems?.[0]?.taxRatePercent || 0,
+        backend: "lexoffice",
+        raw,
+    };
+}
+function fromLexofficeQuotation(raw) {
+    const lineItems = (raw.lineItems || [])
+        .filter((li) => li.type === "custom")
+        .map((li) => ({
+        name: li.name,
+        quantity: li.quantity,
+        unitPrice: li.unitPrice?.netAmount || 0,
+        taxRate: li.unitPrice?.taxRatePercentage || 0,
+    }));
+    return {
+        id: raw.id,
+        contactId: raw.address?.contactId || "",
+        date: raw.voucherDate || "",
+        expirationDate: raw.expirationDate,
+        totalNet: raw.totalPrice?.totalNetAmount || 0,
+        totalGross: raw.totalPrice?.totalGrossAmount || 0,
+        lineItems,
+        backend: "lexoffice",
+        raw,
+    };
+}
+// === Lexoffice Backend ===
+export class LexofficeBackend {
+    name = "lexoffice";
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    // --- Contacts ---
+    async createContact(input) {
+        const body = toLexofficeContact(input);
+        const result = await lexofficeRequest(this.apiKey, "POST", "/contacts", body);
+        return this.getContact(result.id);
+    }
+    async getContact(id) {
+        const raw = await lexofficeRequest(this.apiKey, "GET", `/contacts/${id}`);
+        return fromLexofficeContact(raw);
+    }
+    async listContacts(filter) {
+        const qs = { size: String(filter?.limit || 25) };
+        if (filter?.email)
+            qs.email = filter.email;
+        if (filter?.name)
+            qs.name = filter.name;
+        if (filter?.role === "customer")
+            qs.customer = "true";
+        if (filter?.role === "vendor")
+            qs.vendor = "true";
+        const response = await lexofficeRequest(this.apiKey, "GET", "/contacts", undefined, qs);
+        return (response.content || []).map(fromLexofficeContact);
+    }
+    async updateContact(id, input) {
+        const existing = await lexofficeRequest(this.apiKey, "GET", `/contacts/${id}`);
+        const body = { ...existing, ...input };
+        delete body.id;
+        delete body.resourceUri;
+        if (input.name && body.company) {
+            body.company.name = input.name;
+        }
+        if (input.name && body.person) {
+            body.person.lastName = input.name;
+        }
+        await lexofficeRequest(this.apiKey, "PUT", `/contacts/${id}`, body);
+        return this.getContact(id);
+    }
+    // --- Invoices ---
+    async createInvoice(input) {
+        const body = toLexofficeInvoice(input);
+        const qs = {};
+        if (input.finalize)
+            qs.finalize = "true";
+        const result = await lexofficeRequest(this.apiKey, "POST", "/invoices", body, Object.keys(qs).length ? qs : undefined);
+        return this.getInvoice(result.id);
+    }
+    async getInvoice(id) {
+        const raw = await lexofficeRequest(this.apiKey, "GET", `/invoices/${id}`);
+        return fromLexofficeInvoice(raw);
+    }
+    async listInvoices(filter) {
+        const qs = { size: String(filter?.limit || 25) };
+        if (filter?.status && filter.status !== "overdue") {
+            qs.voucherStatus = filter.status;
+        }
+        if (filter?.contactId) {
+            qs.contactId = filter.contactId;
+        }
+        const response = await lexofficeRequest(this.apiKey, "GET", "/voucherlist", undefined, {
+            ...qs,
+            voucherType: "invoice",
+        });
+        const items = (response.content || []).map(fromLexofficeInvoice);
+        if (filter?.status === "overdue") {
+            const now = Date.now();
+            return items.filter((inv) => new Date(inv.dueDate).getTime() < now && inv.status !== "paid");
+        }
+        return items;
+    }
+    async getInvoicePdf(id) {
+        const docResponse = await lexofficeRequest(this.apiKey, "GET", `/invoices/${id}/document`);
+        const fileId = docResponse.documentFileId;
+        await rateLimitSleep();
+        const fileResponse = await fetch(`${BASE_URL}/files/${fileId}`, {
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+        });
+        if (fileResponse.status === 429) {
+            throw createError(ErrorCode.RATE_LIMITED, "Lexoffice API rate limit exceeded during PDF download");
+        }
+        if (!fileResponse.ok) {
+            throw createError(ErrorCode.BACKEND_ERROR, `Failed to download PDF: ${fileResponse.status}`);
+        }
+        const buffer = Buffer.from(await fileResponse.arrayBuffer());
+        return { data: buffer, filename: `invoice-${id}.pdf` };
+    }
+    async updateInvoice(id, input) {
+        const existing = await lexofficeRequest(this.apiKey, "GET", `/invoices/${id}`);
+        const body = { ...existing, ...input };
+        delete body.id;
+        delete body.resourceUri;
+        delete body.organizationId;
+        await lexofficeRequest(this.apiKey, "PUT", `/invoices/${id}`, body);
+        return this.getInvoice(id);
+    }
+    // --- Vouchers ---
+    async createVoucher(input) {
+        const taxAmount = input.totalGross - (input.totalGross / (1 + input.taxRate / 100));
+        const body = {
+            type: "voucher",
+            voucherType: input.type,
+            voucherDate: input.date,
+            totalGrossAmount: input.totalGross,
+            totalTaxAmount: taxAmount,
+            taxType: "gross",
+            voucherItems: [{
+                    amount: input.totalGross,
+                    taxAmount,
+                    taxRatePercent: input.taxRate,
+                    categoryId: "8f8664a8-fd86-11e1-a21f-0800200c9a66",
+                }],
+            ...(input.contactId && { contactId: input.contactId }),
+            ...(input.remark && { remark: input.remark }),
+        };
+        const result = await lexofficeRequest(this.apiKey, "POST", "/vouchers", body);
+        return this.getVoucher(result.id);
+    }
+    async getVoucher(id) {
+        const raw = await lexofficeRequest(this.apiKey, "GET", `/vouchers/${id}`);
+        return fromLexofficeVoucher(raw);
+    }
+    async listVouchers(filter) {
+        const qs = { size: String(filter?.limit || 25) };
+        if (filter?.type && filter.type !== "any")
+            qs.voucherType = filter.type;
+        const response = await lexofficeRequest(this.apiKey, "GET", "/voucherlist", undefined, qs);
+        return (response.content || []).map(fromLexofficeVoucher);
+    }
+    // --- Quotations ---
+    async createQuotation(input) {
+        const body = {
+            voucherDate: input.date,
+            address: { contactId: input.contactId },
+            lineItems: input.lineItems.map((item) => ({
+                type: "custom",
+                name: item.name,
+                quantity: item.quantity,
+                unitName: "Stueck",
+                unitPrice: {
+                    currency: "EUR",
+                    netAmount: item.unitPrice,
+                    taxRatePercentage: item.taxRate,
+                },
+            })),
+            totalPrice: { currency: "EUR" },
+            taxConditions: { taxType: "net" },
+            ...(input.expirationDate && { expirationDate: input.expirationDate }),
+            ...(input.title && { title: input.title }),
+            ...(input.introduction && { introduction: input.introduction }),
+            ...(input.remark && { remark: input.remark }),
+        };
+        const qs = {};
+        if (input.finalize)
+            qs.finalize = "true";
+        const result = await lexofficeRequest(this.apiKey, "POST", "/quotations", body, Object.keys(qs).length ? qs : undefined);
+        return this.getQuotation(result.id);
+    }
+    async getQuotation(id) {
+        const raw = await lexofficeRequest(this.apiKey, "GET", `/quotations/${id}`);
+        return fromLexofficeQuotation(raw);
+    }
+}