@getpeppr/sdk 0.1.0

package/dist/core/client.js

@@ -0,0 +1,1308 @@
+/**
+ * getpeppr SDK Client
+ *
+ * The main entry point. Designed to feel like Stripe's SDK:
+ *
+ *   const peppol = new Peppol({ apiKey: "sk_live_..." });
+ *   const result = await peppol.invoices.send({ from, to, lines });
+ *
+ * All requests go through the getpeppr API gateway (api.getpeppr.dev),
+ * which handles Peppol delivery, billing, and usage tracking.
+ * Use `baseUrl` to point to a custom instance or localhost.
+ */
+import { buildInvoiceXml } from "./ubl-builder.js";
+import { validateInvoice } from "./validator.js";
+// ─── Retry Utilities ────────────────────────────────────────
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateRetryDelay(attempt, initialDelayMs, maxDelayMs, retryAfterMs) {
+    if (retryAfterMs !== undefined)
+        return Math.min(retryAfterMs, maxDelayMs);
+    const exponentialDelay = initialDelayMs * Math.pow(2, attempt);
+    const jitter = Math.random() * initialDelayMs;
+    return Math.min(exponentialDelay + jitter, maxDelayMs);
+}
+/**
+ * Parse the Retry-After header value into milliseconds.
+ * Supports integer seconds (e.g., "1", "60") and HTTP-date format.
+ * Returns undefined if the header is missing or unparseable.
+ */
+function parseRetryAfter(headerValue) {
+    if (!headerValue)
+        return undefined;
+    // Try integer seconds first (most common for rate limiters)
+    const seconds = Number(headerValue);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    // Try HTTP-date format (e.g., "Wed, 21 Oct 2025 07:28:00 GMT")
+    const dateMs = Date.parse(headerValue);
+    if (!Number.isNaN(dateMs)) {
+        const delayMs = dateMs - Date.now();
+        return delayMs > 0 ? delayMs : 0;
+    }
+    return undefined;
+}
+function isRetryableError(error) {
+    if (error instanceof PeppolApiError) {
+        return RETRYABLE_STATUS_CODES.has(error.statusCode);
+    }
+    // Retry on timeout/abort errors
+    if (error instanceof Error && error.name === "AbortError") {
+        return true;
+    }
+    return false;
+}
+// ─── getpeppr API Adapter ───────────────────────────────────
+const DEFAULT_BASE_URL = "https://api.getpeppr.dev/v1";
+class GetpepprAdapter {
+    name = "getpeppr";
+    baseUrl;
+    apiKey;
+    timeout;
+    retryConfig;
+    onRequest;
+    onResponse;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.timeout = config.timeout ?? 30_000;
+        this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+        this.retryConfig = {
+            maxRetries: config.retry?.maxRetries ?? 3,
+            initialDelayMs: config.retry?.initialDelayMs ?? 500,
+            maxDelayMs: config.retry?.maxDelayMs ?? 30_000,
+        };
+        this.onRequest = config.onRequest;
+        this.onResponse = config.onResponse;
+    }
+    async request(method, path, body, extraHeaders) {
+        const { maxRetries, initialDelayMs, maxDelayMs } = this.retryConfig;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await this.doRequest(method, path, body, extraHeaders);
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt < maxRetries && isRetryableError(err)) {
+                    const retryAfterMs = err instanceof PeppolApiError ? err.retryAfterMs : undefined;
+                    await sleep(calculateRetryDelay(attempt, initialDelayMs, maxDelayMs, retryAfterMs));
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw lastError;
+    }
+    async doRequest(method, path, body, extraHeaders) {
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const requestHeaders = {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...extraHeaders,
+        };
+        const startTime = Date.now();
+        if (this.onRequest) {
+            try {
+                this.onRequest({
+                    method,
+                    url,
+                    headers: { ...requestHeaders },
+                    body,
+                    timestamp: startTime,
+                });
+            }
+            catch {
+                // Hook errors must never break the request
+            }
+        }
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: requestHeaders,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => "Unknown error");
+                const retryAfterMs = response.status === 429
+                    ? parseRetryAfter(response.headers.get("Retry-After"))
+                    : undefined;
+                if (this.onResponse) {
+                    try {
+                        this.onResponse({
+                            status: response.status,
+                            headers: Object.fromEntries(response.headers.entries()),
+                            body: errorBody,
+                            durationMs: Date.now() - startTime,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    catch {
+                        // Hook errors must never break the request
+                    }
+                }
+                throw new PeppolApiError(`getpeppr API error (${response.status}): ${errorBody}`, response.status, errorBody, retryAfterMs);
+            }
+            // 204 No Content — no body to parse (e.g., sendInvoiceById)
+            if (response.status === 204) {
+                if (this.onResponse) {
+                    try {
+                        this.onResponse({
+                            status: response.status,
+                            headers: Object.fromEntries(response.headers.entries()),
+                            body: undefined,
+                            durationMs: Date.now() - startTime,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    catch {
+                        // Hook errors must never break the request
+                    }
+                }
+                return undefined;
+            }
+            const responseBody = (await response.json());
+            if (this.onResponse) {
+                try {
+                    this.onResponse({
+                        status: response.status,
+                        headers: Object.fromEntries(response.headers.entries()),
+                        body: responseBody,
+                        durationMs: Date.now() - startTime,
+                        timestamp: Date.now(),
+                    });
+                }
+                catch {
+                    // Hook errors must never break the request
+                }
+            }
+            return responseBody;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    // NOTE: sendInvoice and createInvoice hit the same SDK endpoint (POST /invoices).
+    // The gateway (Tasks 9-10) differentiates them: sendInvoice wraps with
+    // { invoice: {...}, send_after_import: true }, createInvoice omits the flag.
+    async sendInvoice(input, options) {
+        const headers = {};
+        if (options?.idempotencyKey) {
+            headers["Idempotency-Key"] = options.idempotencyKey;
+        }
+        const result = await this.request("POST", "/invoices", input, headers);
+        return parseSendResult(result);
+    }
+    async createInvoice(input, options) {
+        const headers = {};
+        if (options?.idempotencyKey) {
+            headers["Idempotency-Key"] = options.idempotencyKey;
+        }
+        // Signal to the gateway that this is a draft (no auto-send).
+        // The gateway reads `_draft` and strips it before forwarding to B2BRouter.
+        const result = await this.request("POST", "/invoices", { ...input, _draft: true }, headers);
+        return parseSendResult(result);
+    }
+    async sendInvoiceById(id) {
+        await this.request("POST", `/invoices/send/${id}`);
+    }
+    async sendCreditNote(input) {
+        const result = await this.request("POST", "/credit-notes", input);
+        return parseSendResult(result);
+    }
+    async validateDocument(input) {
+        return this.request("POST", "/validate", input);
+    }
+    async listReceived(options) {
+        const limit = options?.limit ?? 25;
+        const offset = options?.offset ?? 0;
+        const result = await this.request("GET", `/invoices?limit=${limit}&offset=${offset}`);
+        return (result.data ?? []).map((inv) => ({
+            id: String(inv.id),
+            invoice: inv,
+            rawXml: String(inv.ubl_xml ?? ""),
+            senderId: String(inv.sender_peppol_id ?? ""),
+            receivedAt: String(inv.received_at ?? new Date().toISOString()),
+        }));
+    }
+    async listInvoices(options) {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.offset)
+            params.set("offset", String(options.offset));
+        if (options?.type)
+            params.set("type", options.type);
+        if (options?.includeLines)
+            params.set("include", "lines");
+        const query = params.toString() ? `?${params.toString()}` : "";
+        const result = await this.request("GET", `/invoices${query}`);
+        // B2BRouter wraps list in "invoices" key (plural), not "data"
+        const invoices = (result.invoices ?? result.data ?? []);
+        const meta = result.meta;
+        return {
+            data: invoices.map((inv) => ({
+                id: String(inv.id ?? ""),
+                number: String(inv.number ?? ""),
+                status: mapStatus(String(inv.state ?? inv.status ?? "new")),
+                createdAt: inv.created_at ? String(inv.created_at) : undefined,
+            })),
+            meta: {
+                totalCount: Number(meta?.total_count ?? invoices.length),
+                offset: Number(meta?.offset ?? options?.offset ?? 0),
+                limit: Number(meta?.limit ?? options?.limit ?? 25),
+                hasMore: meta ? Number(meta.total_count) > Number(meta.offset) + Number(meta.limit) : false,
+            },
+        };
+    }
+    async getStatus(documentId) {
+        const result = await this.request("GET", `/invoices/${documentId}`);
+        return parseSendResult(result);
+    }
+    async lookupDirectory(scheme, id) {
+        return this.request("GET", `/directory/${scheme}/${id}`);
+    }
+    async getInvoiceAs(id, format) {
+        const { maxRetries, initialDelayMs, maxDelayMs } = this.retryConfig;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await this.doRequestBinary(`/invoices/${id}/as/${format}`);
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt < maxRetries && isRetryableError(err)) {
+                    const retryAfterMs = err instanceof PeppolApiError ? err.retryAfterMs : undefined;
+                    await sleep(calculateRetryDelay(attempt, initialDelayMs, maxDelayMs, retryAfterMs));
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw lastError;
+    }
+    async doRequestBinary(path) {
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const requestHeaders = {
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+        const startTime = Date.now();
+        if (this.onRequest) {
+            try {
+                this.onRequest({
+                    method: "GET",
+                    url,
+                    headers: { ...requestHeaders },
+                    timestamp: startTime,
+                });
+            }
+            catch {
+                // Hook errors must never break the request
+            }
+        }
+        try {
+            const response = await fetch(url, {
+                method: "GET",
+                headers: requestHeaders,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => "Unknown error");
+                const retryAfterMs = response.status === 429
+                    ? parseRetryAfter(response.headers.get("Retry-After"))
+                    : undefined;
+                if (this.onResponse) {
+                    try {
+                        this.onResponse({
+                            status: response.status,
+                            headers: Object.fromEntries(response.headers.entries()),
+                            body: errorBody,
+                            durationMs: Date.now() - startTime,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    catch {
+                        // Hook errors must never break the request
+                    }
+                }
+                throw new PeppolApiError(`getpeppr API error (${response.status}): ${errorBody}`, response.status, errorBody, retryAfterMs);
+            }
+            const responseBody = await response.arrayBuffer();
+            if (this.onResponse) {
+                try {
+                    this.onResponse({
+                        status: response.status,
+                        headers: Object.fromEntries(response.headers.entries()),
+                        body: `[ArrayBuffer: ${responseBody.byteLength} bytes]`,
+                        durationMs: Date.now() - startTime,
+                        timestamp: Date.now(),
+                    });
+                }
+                catch {
+                    // Hook errors must never break the request
+                }
+            }
+            return responseBody;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async validateDocumentServer(input) {
+        return this.request("POST", "/validate/server", input);
+    }
+    async listEvents(options) {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.offset)
+            params.set("offset", String(options.offset));
+        if (options?.invoiceId)
+            params.set("invoiceId", options.invoiceId);
+        if (options?.dateFrom)
+            params.set("dateFrom", options.dateFrom);
+        if (options?.dateTo)
+            params.set("dateTo", options.dateTo);
+        const query = params.toString() ? `?${params.toString()}` : "";
+        const result = await this.request("GET", `/events${query}`);
+        const events = (result.events ?? result.data ?? []);
+        const meta = result.meta;
+        return {
+            data: events.map((evt) => ({
+                name: String(evt.name ?? ""),
+                text: String(evt.text ?? ""),
+                notes: evt.notes ? String(evt.notes) : undefined,
+                createdAt: String(evt.createdAt ?? evt.created_at ?? new Date().toISOString()),
+                invoice: evt.invoice,
+                contact: evt.contact,
+            })),
+            meta: {
+                totalCount: Number(meta?.total_count ?? meta?.totalCount ?? events.length),
+                offset: Number(meta?.offset ?? options?.offset ?? 0),
+                limit: Number(meta?.limit ?? options?.limit ?? 25),
+                hasMore: meta
+                    ? Number(meta.total_count ?? meta.totalCount) > Number(meta.offset) + Number(meta.limit)
+                    : false,
+            },
+        };
+    }
+    async acknowledgeInvoice(id) {
+        const result = await this.request("POST", `/invoices/${id}/ack`);
+        return parseSendResult(result);
+    }
+    async listContacts(options) {
+        const params = new URLSearchParams();
+        if (options?.limit != null)
+            params.set("limit", String(options.limit));
+        if (options?.offset != null)
+            params.set("offset", String(options.offset));
+        if (options?.name)
+            params.set("name", options.name);
+        if (options?.isClient != null)
+            params.set("isClient", String(options.isClient));
+        if (options?.isProvider != null)
+            params.set("isProvider", String(options.isProvider));
+        const query = params.toString() ? `?${params.toString()}` : "";
+        const result = await this.request("GET", `/contacts${query}`);
+        const contacts = (result.contacts ?? result.data ?? []);
+        const meta = result.meta;
+        return {
+            data: contacts.map(parseContact),
+            meta: {
+                totalCount: Number(meta?.total_count ?? meta?.totalCount ?? contacts.length),
+                offset: Number(meta?.offset ?? options?.offset ?? 0),
+                limit: Number(meta?.limit ?? options?.limit ?? 25),
+                hasMore: meta
+                    ? Number(meta.total_count ?? meta.totalCount) > Number(meta.offset) + Number(meta.limit)
+                    : false,
+            },
+        };
+    }
+    async getContact(id) {
+        const result = await this.request("GET", `/contacts/${id}`);
+        return parseContact(result);
+    }
+    async createContact(input) {
+        const result = await this.request("POST", "/contacts", input);
+        return parseContact(result);
+    }
+    async updateContact(id, input) {
+        const result = await this.request("PUT", `/contacts/${id}`, input);
+        return parseContact(result);
+    }
+    async deleteContact(id) {
+        await this.request("DELETE", `/contacts/${id}`);
+    }
+    async listBankAccounts(options) {
+        const params = new URLSearchParams();
+        if (options?.limit != null)
+            params.set("limit", String(options.limit));
+        if (options?.offset != null)
+            params.set("offset", String(options.offset));
+        const query = params.toString() ? `?${params.toString()}` : "";
+        const result = await this.request("GET", `/bank-accounts${query}`);
+        const bankAccounts = (result.bankAccounts ?? result.data ?? []);
+        const meta = result.meta;
+        return {
+            data: bankAccounts.map(parseBankAccount),
+            meta: {
+                totalCount: Number(meta?.total_count ?? meta?.totalCount ?? bankAccounts.length),
+                offset: Number(meta?.offset ?? options?.offset ?? 0),
+                limit: Number(meta?.limit ?? options?.limit ?? 25),
+                hasMore: meta
+                    ? Number(meta.total_count ?? meta.totalCount) > Number(meta.offset) + Number(meta.limit)
+                    : false,
+            },
+        };
+    }
+    async getBankAccount(id) {
+        const result = await this.request("GET", `/bank-accounts/${id}`);
+        return parseBankAccount(result);
+    }
+    async createBankAccount(input) {
+        const result = await this.request("POST", "/bank-accounts", input);
+        return parseBankAccount(result);
+    }
+    async updateBankAccount(id, input) {
+        const result = await this.request("PUT", `/bank-accounts/${id}`, input);
+        return parseBankAccount(result);
+    }
+    async deleteBankAccount(id) {
+        await this.request("DELETE", `/bank-accounts/${id}`);
+    }
+    async importInvoice(options) {
+        const body = {
+            file: arrayBufferToBase64(options.file),
+            filename: options.filename,
+            mimeType: options.mimeType ?? detectMimeType(options.filename),
+        };
+        const result = await this.request("POST", "/invoices/import", body);
+        return parseSendResult(result);
+    }
+    async listTransportTypes() {
+        const result = await this.request("GET", "/transports/types");
+        const types = (result.transportTypes ?? result.data ?? []);
+        return types.map((t) => ({
+            code: String(t.code ?? ""),
+            name: String(t.name ?? ""),
+        }));
+    }
+    async listTransports() {
+        const result = await this.request("GET", "/transports");
+        const transports = (result.transports ?? result.data ?? []);
+        return transports.map((t) => ({
+            id: String(t.id ?? ""),
+            transportTypeCode: String(t.transportTypeCode ?? ""),
+            name: String(t.name ?? ""),
+            status: t.status ? String(t.status) : undefined,
+        }));
+    }
+}
+// ─── Import Helpers ──────────────────────────────────────────
+/** Convert ArrayBuffer or Uint8Array to base64 string (works in all runtimes). */
+export function arrayBufferToBase64(buffer) {
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+/** Detect MIME type from a filename's extension. */
+export function detectMimeType(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    switch (ext) {
+        case "xml": return "application/xml";
+        case "pdf": return "application/pdf";
+        case "json": return "application/json";
+        default: return "application/octet-stream";
+    }
+}
+function parseSendResult(result) {
+    return {
+        id: String(result.id ?? ""),
+        status: mapStatus(String(result.status ?? "new")),
+        peppolMessageId: (result.peppolMessageId ?? result.peppol_message_id),
+        createdAt: String(result.createdAt ?? result.updatedAt ?? result.created_at ?? new Date().toISOString()),
+    };
+}
+function parseContact(raw) {
+    const contact = {
+        id: String(raw.id ?? ""),
+        name: String(raw.name ?? ""),
+    };
+    if (raw.peppolId != null)
+        contact.peppolId = String(raw.peppolId);
+    if (raw.vatNumber != null)
+        contact.vatNumber = String(raw.vatNumber);
+    if (raw.companyId != null)
+        contact.companyId = String(raw.companyId);
+    if (raw.street != null)
+        contact.street = String(raw.street);
+    if (raw.city != null)
+        contact.city = String(raw.city);
+    if (raw.postalCode != null)
+        contact.postalCode = String(raw.postalCode);
+    if (raw.country != null)
+        contact.country = String(raw.country);
+    if (raw.email != null)
+        contact.email = String(raw.email);
+    if (raw.isClient != null)
+        contact.isClient = Boolean(raw.isClient);
+    if (raw.isProvider != null)
+        contact.isProvider = Boolean(raw.isProvider);
+    if (raw.createdAt != null)
+        contact.createdAt = String(raw.createdAt);
+    if (raw.updatedAt != null)
+        contact.updatedAt = String(raw.updatedAt);
+    return contact;
+}
+function parseBankAccount(raw) {
+    const account = {
+        id: String(raw.id ?? ""),
+        name: String(raw.name ?? ""),
+        type: (raw.type === "number" ? "number" : "iban"),
+    };
+    if (raw.iban != null)
+        account.iban = String(raw.iban);
+    if (raw.number != null)
+        account.number = String(raw.number);
+    if (raw.bic != null)
+        account.bic = String(raw.bic);
+    if (raw.country != null)
+        account.country = String(raw.country);
+    if (raw.createdAt != null)
+        account.createdAt = String(raw.createdAt);
+    if (raw.updatedAt != null)
+        account.updatedAt = String(raw.updatedAt);
+    return account;
+}
+// B2BRouter StateOutput enum — the canonical set of document lifecycle states.
+const VALID_STATUSES = new Set([
+    "new", "sent", "downloaded", "accepted", "registered",
+    "refused", "allegedly_paid", "paid", "closed", "annotated", "error", "invalid",
+]);
+function mapStatus(raw) {
+    // B2BRouter uses "state" field; gateway maps to "status" for SDK DX.
+    // We validate against the known enum and fall back to "new" for unknowns.
+    const s = raw.toLowerCase();
+    return VALID_STATUSES.has(s) ? s : "new";
+}
+// ─── Error Classes ──────────────────────────────────────────
+export class PeppolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PeppolError";
+    }
+}
+export class PeppolValidationError extends PeppolError {
+    validation;
+    constructor(message, validation) {
+        super(message);
+        this.validation = validation;
+        this.name = "PeppolValidationError";
+    }
+}
+export class PeppolApiError extends PeppolError {
+    statusCode;
+    responseBody;
+    /** Parsed Retry-After delay in milliseconds (present on 429 responses) */
+    retryAfterMs;
+    constructor(message, statusCode, responseBody, retryAfterMs) {
+        super(message);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = "PeppolApiError";
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+// ─── Main SDK Client ────────────────────────────────────────
+export class Peppol {
+    adapter;
+    invoices;
+    creditNotes;
+    directory;
+    events;
+    contacts;
+    bankAccounts;
+    transports;
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new PeppolError('API key is required. Sign up at https://console.getpeppr.dev to get your sandbox key.');
+        }
+        this.adapter = new GetpepprAdapter(config);
+        this.invoices = new InvoiceOperations(this.adapter);
+        this.creditNotes = new CreditNoteOperations(this.adapter);
+        this.directory = new DirectoryOperations(this.adapter);
+        this.events = new EventOperations(this.adapter);
+        this.contacts = new ContactOperations(this.adapter);
+        this.bankAccounts = new BankAccountOperations(this.adapter);
+        this.transports = new TransportOperations(this.adapter);
+    }
+    /**
+     * Validate an invoice without sending it.
+     * Useful for pre-flight checks in your UI.
+     */
+    validate(input) {
+        return validateInvoice(input);
+    }
+    /**
+     * Generate UBL XML without sending.
+     * Useful for debugging or manual submission.
+     */
+    toXml(input) {
+        const validation = validateInvoice(input);
+        if (!validation.valid) {
+            throw new PeppolValidationError(`Invoice validation failed: ${validation.errors.map((e) => e.message).join("; ")}`, validation);
+        }
+        return buildInvoiceXml(input);
+    }
+}
+async function* paginate(fetchPage, options) {
+    const pageSize = options?.limit ?? 25;
+    let offset = 0;
+    while (true) {
+        const page = await fetchPage(offset, pageSize);
+        for (const item of page.data) {
+            yield item;
+        }
+        if (!page.meta.hasMore)
+            break;
+        offset += pageSize;
+    }
+}
+class InvoiceOperations {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * Create a draft invoice without sending it.
+     * Validates input client-side, then creates the invoice on B2BRouter.
+     * Use `sendById()` to send the draft when ready.
+     *
+     * @example
+     * ```ts
+     * const draft = await peppol.invoices.create({ number: "INV-001", to, lines });
+     * // Later, when ready:
+     * await peppol.invoices.sendById(draft.id);
+     * ```
+     */
+    async create(input, options) {
+        const validation = validateInvoice(input);
+        if (!validation.valid) {
+            throw new PeppolValidationError(`Invoice validation failed:\n${validation.errors.map((e) => `  - ${e.field}: ${e.message}${e.suggestion ? ` (${e.suggestion})` : ""}`).join("\n")}`, validation);
+        }
+        const result = await this.adapter.createInvoice(input, options);
+        if (validation.warnings.length > 0) {
+            result.warnings = validation.warnings;
+        }
+        return result;
+    }
+    /**
+     * Send an existing draft invoice by ID.
+     * The invoice must have been previously created with `create()`.
+     *
+     * @example
+     * ```ts
+     * await peppol.invoices.sendById("inv-1");
+     * ```
+     */
+    async sendById(id) {
+        return this.adapter.sendInvoiceById(id);
+    }
+    /**
+     * Send an invoice via Peppol.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.invoices.send({
+     *   number: "INV-001",
+     *   from: { name: "My Company", peppolId: "0208:BE0123456789", country: "BE" },
+     *   to: { name: "Client Co", peppolId: "0208:BE9876543210", country: "BE" },
+     *   lines: [
+     *     { description: "Consulting", quantity: 10, unitPrice: 150, vatRate: 21 }
+     *   ]
+     * });
+     * ```
+     */
+    async send(input, options) {
+        // Client-side validation for fast feedback
+        const validation = validateInvoice(input);
+        if (!validation.valid) {
+            throw new PeppolValidationError(`Invoice validation failed:\n${validation.errors.map((e) => `  - ${e.field}: ${e.message}${e.suggestion ? ` (${e.suggestion})` : ""}`).join("\n")}`, validation);
+        }
+        // Send structured JSON — gateway handles UBL generation
+        const result = await this.adapter.sendInvoice(input, options);
+        if (validation.warnings.length > 0) {
+            result.warnings = validation.warnings;
+        }
+        return result;
+    }
+    /** List invoices with pagination, filtering, and proper metadata */
+    async list(options) {
+        return this.adapter.listInvoices(options);
+    }
+    /**
+     * Async iterator over all invoices, automatically handling pagination.
+     *
+     * @example
+     * ```ts
+     * for await (const invoice of peppol.invoices.listAll({ type: "issued" })) {
+     *   console.log(invoice.id, invoice.status);
+     * }
+     * ```
+     */
+    listAll(options) {
+        return paginate((offset, limit) => this.adapter.listInvoices({ ...options, offset, limit }), options);
+    }
+    /** List received invoices */
+    async listReceived(options) {
+        return this.adapter.listReceived(options);
+    }
+    /** Get the status of a sent invoice */
+    async getStatus(documentId) {
+        return this.adapter.getStatus(documentId);
+    }
+    /**
+     * Export an invoice in a specific format (e.g., PDF, UBL XML).
+     * Returns raw binary data as an ArrayBuffer.
+     *
+     * @example
+     * ```ts
+     * const pdf = await peppol.invoices.getAs("inv-123", "pdf");
+     * fs.writeFileSync("invoice.pdf", Buffer.from(pdf));
+     * ```
+     */
+    async getAs(id, format) {
+        return this.adapter.getInvoiceAs(id, format);
+    }
+    /**
+     * Validate an invoice server-side using XSD and Schematron rules.
+     * Builds UBL XML from the input and sends it to the server for validation.
+     * More thorough than client-side validation — catches XML-level issues.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.invoices.validateServer({
+     *   number: "INV-001",
+     *   to: { name: "Acme", peppolId: "0208:BE0123456789", country: "BE" },
+     *   lines: [{ description: "Item", quantity: 1, unitPrice: 100, vatRate: 21 }]
+     * });
+     * console.log(result.valid, result.schematron.errors);
+     * ```
+     */
+    async validateServer(input) {
+        return this.adapter.validateDocumentServer(input);
+    }
+    /**
+     * Import an invoice from a file (XML, PDF, JSON).
+     * The file is base64-encoded and sent to the gateway, which forwards it
+     * as multipart/form-data to B2BRouter's import endpoint.
+     *
+     * @example
+     * ```ts
+     * const xmlBytes = fs.readFileSync("invoice.xml");
+     * const result = await peppol.invoices.importFile({
+     *   file: xmlBytes,
+     *   filename: "invoice.xml",
+     * });
+     * console.log(result.id, result.status);
+     * ```
+     */
+    async importFile(options) {
+        return this.adapter.importInvoice(options);
+    }
+    /**
+     * Acknowledge a received invoice.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.invoices.acknowledge("inv-123");
+     * console.log(result.status); // "accepted"
+     * ```
+     */
+    async acknowledge(id) {
+        return this.adapter.acknowledgeInvoice(id);
+    }
+    /**
+     * Send multiple invoices in parallel with controlled concurrency.
+     * Each invoice is validated and sent individually — failures don't affect other invoices
+     * unless `stopOnError: true` is set.
+     *
+     * The SDK's built-in retry logic (including 429 Retry-After) provides automatic
+     * rate-limit handling at the request level.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.invoices.sendBatch([invoice1, invoice2, invoice3], {
+     *   concurrency: 3,
+     * });
+     * console.log(`${result.succeeded.length} sent, ${result.failed.length} failed`);
+     * ```
+     */
+    async sendBatch(inputs, options) {
+        const concurrency = options?.concurrency ?? 5;
+        const stopOnError = options?.stopOnError ?? false;
+        const succeeded = [];
+        const failed = [];
+        let stopped = false;
+        // Process in chunks of `concurrency` size
+        for (let i = 0; i < inputs.length; i += concurrency) {
+            if (stopped)
+                break;
+            const chunk = inputs.slice(i, i + concurrency);
+            const promises = chunk.map(async (input, j) => {
+                const index = i + j;
+                if (stopped)
+                    return;
+                try {
+                    const result = await this.send(input);
+                    succeeded.push({ index, result });
+                }
+                catch (error) {
+                    failed.push({ index, input, error: error });
+                    if (stopOnError) {
+                        stopped = true;
+                    }
+                }
+            });
+            await Promise.all(promises);
+        }
+        return { succeeded, failed, total: inputs.length };
+    }
+    /**
+     * Poll until an invoice reaches a target status.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.invoices.waitFor(id, "accepted", { timeout: 60000 });
+     * ```
+     */
+    async waitFor(documentId, targetStatus, options) {
+        const timeout = options?.timeout ?? 120_000;
+        const interval = options?.interval ?? 5_000;
+        const targets = Array.isArray(targetStatus) ? targetStatus : [targetStatus];
+        const terminalFailures = ["error", "refused", "invalid"];
+        const startTime = Date.now();
+        while (true) {
+            const result = await this.getStatus(documentId);
+            if (targets.includes(result.status)) {
+                return result;
+            }
+            if (terminalFailures.includes(result.status)) {
+                throw new PeppolError(`Document ${documentId} reached terminal status "${result.status}" while waiting for "${targets.join('" or "')}"`);
+            }
+            if (Date.now() - startTime + interval > timeout) {
+                throw new PeppolError(`Timed out waiting for document ${documentId} to reach status "${targets.join('" or "')}" (last: "${result.status}")`);
+            }
+            await sleep(interval);
+        }
+    }
+}
+/** @deprecated Use peppol.invoices.send() with isCreditNote: true instead */
+class CreditNoteOperations {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * Send a credit note via Peppol.
+     * @deprecated Use peppol.invoices.send({ ...input, isCreditNote: true }) instead.
+     */
+    async send(input) {
+        // Convert to InvoiceInput with isCreditNote flag and delegate to sendInvoice
+        const invoiceInput = {
+            ...input,
+            isCreditNote: true,
+            invoiceReference: input.invoiceReference,
+        };
+        const validation = validateInvoice(invoiceInput);
+        if (!validation.valid) {
+            throw new PeppolValidationError(`Credit note validation failed:\n${validation.errors.map((e) => `  - ${e.field}: ${e.message}`).join("\n")}`, validation);
+        }
+        // Route through sendInvoice — B2BRouter has no separate credit-notes endpoint
+        return this.adapter.sendInvoice(invoiceInput);
+    }
+}
+// ─── Directory Operations ───────────────────────────────────
+class DirectoryOperations {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * Look up a Peppol participant in the directory.
+     *
+     * @example
+     * ```ts
+     * const entry = await peppol.directory.lookup("0208:BE0123456789");
+     * console.log(entry.name, entry.capabilities);
+     * ```
+     */
+    async lookup(peppolId) {
+        const colonIndex = peppolId.indexOf(":");
+        if (colonIndex === -1) {
+            throw new PeppolError('Invalid Peppol ID format. Expected "scheme:id" (e.g., "0208:BE0123456789")');
+        }
+        const scheme = peppolId.slice(0, colonIndex);
+        const id = peppolId.slice(colonIndex + 1);
+        return this.adapter.lookupDirectory(scheme, id);
+    }
+}
+// ─── Event Operations ────────────────────────────────────────
+class EventOperations {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List events with optional filtering and pagination.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.events.list({ limit: 10 });
+     * console.log(result.data, result.meta);
+     *
+     * // Filter by invoice
+     * const invoiceEvents = await peppol.events.list({ invoiceId: "inv-123" });
+     * ```
+     */
+    async list(options) {
+        return this.adapter.listEvents(options);
+    }
+    /**
+     * Async iterator over all events, automatically handling pagination.
+     *
+     * @example
+     * ```ts
+     * for await (const event of peppol.events.listAll({ invoiceId: "inv-123" })) {
+     *   console.log(event.name, event.createdAt);
+     * }
+     * ```
+     */
+    listAll(options) {
+        return paginate((offset, limit) => this.adapter.listEvents({ ...options, offset, limit }), options);
+    }
+}
+// ─── Contact Operations ─────────────────────────────────────
+class ContactOperations {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List contacts with optional filtering and pagination.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.contacts.list({ limit: 10, isClient: true });
+     * console.log(result.data, result.meta);
+     * ```
+     */
+    async list(options) {
+        return this.adapter.listContacts(options);
+    }
+    /**
+     * Get a single contact by ID.
+     *
+     * @example
+     * ```ts
+     * const contact = await peppol.contacts.get("123");
+     * console.log(contact.name, contact.peppolId);
+     * ```
+     */
+    async get(id) {
+        return this.adapter.getContact(id);
+    }
+    /**
+     * Create a new contact.
+     *
+     * @example
+     * ```ts
+     * const contact = await peppol.contacts.create({
+     *   name: "Acme Corp",
+     *   peppolId: "0208:BE0123456789",
+     *   country: "BE",
+     *   isClient: true,
+     * });
+     * ```
+     */
+    async create(input) {
+        return this.adapter.createContact(input);
+    }
+    /**
+     * Update an existing contact.
+     *
+     * @example
+     * ```ts
+     * const updated = await peppol.contacts.update("123", { email: "new@acme.com" });
+     * ```
+     */
+    async update(id, input) {
+        return this.adapter.updateContact(id, input);
+    }
+    /**
+     * Delete a contact.
+     *
+     * @example
+     * ```ts
+     * await peppol.contacts.delete("123");
+     * ```
+     */
+    async delete(id) {
+        return this.adapter.deleteContact(id);
+    }
+    /**
+     * Async iterator over all contacts, automatically handling pagination.
+     *
+     * @example
+     * ```ts
+     * for await (const contact of peppol.contacts.listAll({ isClient: true })) {
+     *   console.log(contact.name, contact.peppolId);
+     * }
+     * ```
+     */
+    listAll(options) {
+        return paginate((offset, limit) => this.adapter.listContacts({ ...options, offset, limit }));
+    }
+}
+// ─── Bank Account Operations ─────────────────────────────────
+class BankAccountOperations {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List bank accounts with optional pagination.
+     *
+     * @example
+     * ```ts
+     * const result = await peppol.bankAccounts.list({ limit: 10 });
+     * console.log(result.data, result.meta);
+     * ```
+     */
+    async list(options) {
+        return this.adapter.listBankAccounts(options);
+    }
+    /**
+     * Get a single bank account by ID.
+     *
+     * @example
+     * ```ts
+     * const account = await peppol.bankAccounts.get("123");
+     * console.log(account.name, account.iban);
+     * ```
+     */
+    async get(id) {
+        return this.adapter.getBankAccount(id);
+    }
+    /**
+     * Create a new bank account.
+     *
+     * @example
+     * ```ts
+     * const account = await peppol.bankAccounts.create({
+     *   name: "Main Account",
+     *   iban: "BE68539007547034",
+     *   bic: "BBRUBEBB",
+     *   country: "BE",
+     * });
+     * ```
+     */
+    async create(input) {
+        return this.adapter.createBankAccount(input);
+    }
+    /**
+     * Update an existing bank account.
+     *
+     * @example
+     * ```ts
+     * const updated = await peppol.bankAccounts.update("123", { name: "Updated Name" });
+     * ```
+     */
+    async update(id, input) {
+        return this.adapter.updateBankAccount(id, input);
+    }
+    /**
+     * Delete a bank account.
+     *
+     * @example
+     * ```ts
+     * await peppol.bankAccounts.delete("123");
+     * ```
+     */
+    async delete(id) {
+        return this.adapter.deleteBankAccount(id);
+    }
+    /**
+     * Async iterator over all bank accounts, automatically handling pagination.
+     *
+     * @example
+     * ```ts
+     * for await (const account of peppol.bankAccounts.listAll()) {
+     *   console.log(account.name, account.iban);
+     * }
+     * ```
+     */
+    listAll(options) {
+        return paginate((offset, limit) => this.adapter.listBankAccounts({ ...options, offset, limit }));
+    }
+}
+// ─── Transport Operations ────────────────────────────────────
+class TransportOperations {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List all available transport types in the network.
+     * Returns global transport types (not account-scoped).
+     *
+     * @example
+     * ```ts
+     * const types = await peppol.transports.listTypes();
+     * console.log(types); // [{ code: "peppol", name: "Peppol BIS 3.0" }, ...]
+     * ```
+     */
+    async listTypes() {
+        return this.adapter.listTransportTypes();
+    }
+    /**
+     * List configured transports for this account.
+     *
+     * @example
+     * ```ts
+     * const transports = await peppol.transports.list();
+     * console.log(transports); // [{ id: "t-1", transportTypeCode: "peppol", name: "..." }, ...]
+     * ```
+     */
+    async list() {
+        return this.adapter.listTransports();
+    }
+}
+// ─── Webhook Helper ─────────────────────────────────────────
+/** Default tolerance for webhook timestamp verification (5 minutes) */
+const DEFAULT_TOLERANCE_SECONDS = 300;
+/**
+ * Parse and verify a webhook payload from B2BRouter.
+ *
+ * B2BRouter signs webhooks with HMAC-SHA256. The signature header format is:
+ *   `X-B2Brouter-Signature: t={timestamp},s={hmac_sha256_hex}`
+ *
+ * The signed payload is: `{timestamp}.{raw_json_body}`
+ *
+ * @example
+ * ```ts
+ * app.post("/webhooks/peppol", (req, res) => {
+ *   try {
+ *     const event = Peppol.webhooks.parse(
+ *       req.body,                                    // raw body string
+ *       req.headers["x-b2brouter-signature"],        // signature header
+ *       "whsec_your_webhook_secret",                 // your webhook secret
+ *     );
+ *     switch (event.type) {
+ *       case "invoice.received":
+ *         console.log("New invoice from:", event.data.senderId);
+ *         break;
+ *     }
+ *     res.sendStatus(200);
+ *   } catch (err) {
+ *     res.status(400).send("Webhook verification failed");
+ *   }
+ * });
+ * ```
+ */
+export const webhooks = {
+    /**
+     * Parse a webhook payload without signature verification.
+     * Use `constructEvent()` for verified parsing in production.
+     */
+    parse(payload) {
+        return payload;
+    },
+    /**
+     * Verify and parse a webhook payload using HMAC-SHA256 signature.
+     * Throws `PeppolError` if verification fails.
+     *
+     * @param rawBody — The raw request body string (NOT parsed JSON)
+     * @param signatureHeader — The `X-B2Brouter-Signature` header value
+     * @param secret — Your webhook secret from B2BRouter
+     * @param toleranceSeconds — Max age of the webhook in seconds (default: 300 = 5 min)
+     */
+    async constructEvent(rawBody, signatureHeader, secret, toleranceSeconds) {
+        if (!rawBody) {
+            throw new PeppolError("Webhook error: missing request body");
+        }
+        if (!signatureHeader) {
+            throw new PeppolError("Webhook error: missing X-B2Brouter-Signature header");
+        }
+        if (!secret) {
+            throw new PeppolError("Webhook error: missing webhook secret");
+        }
+        // Parse header: t={timestamp},s={signature}
+        const match = signatureHeader.match(/t=([^,]+),s=(.+)/);
+        if (!match) {
+            throw new PeppolError("Webhook error: invalid signature header format. Expected 't={timestamp},s={signature}'");
+        }
+        const [, timestampStr, receivedSignature] = match;
+        const timestamp = Number(timestampStr);
+        if (!Number.isFinite(timestamp)) {
+            throw new PeppolError("Webhook error: invalid timestamp in signature header");
+        }
+        // Check timestamp tolerance (prevent replay attacks)
+        const tolerance = toleranceSeconds ?? DEFAULT_TOLERANCE_SECONDS;
+        const now = Math.floor(Date.now() / 1000);
+        if (Math.abs(now - timestamp) > tolerance) {
+            throw new PeppolError(`Webhook error: timestamp too old or too new (received: ${timestamp}, now: ${now}, tolerance: ${tolerance}s)`);
+        }
+        // Compute expected signature: HMAC-SHA256(secret, "{timestamp}.{rawBody}")
+        const signedPayload = `${timestampStr}.${rawBody}`;
+        const expectedSignature = await computeHmacSha256(secret, signedPayload);
+        // Constant-time comparison to prevent timing attacks
+        if (!timingSafeEqual(expectedSignature, receivedSignature)) {
+            throw new PeppolError("Webhook error: signature verification failed");
+        }
+        // Parse and return the event
+        try {
+            const parsed = typeof rawBody === "string" ? JSON.parse(rawBody) : rawBody;
+            return parsed;
+        }
+        catch {
+            throw new PeppolError("Webhook error: invalid JSON payload");
+        }
+    },
+};
+/**
+ * Compute HMAC-SHA256 hex digest.
+ * Uses Web Crypto API (works in Node.js 18+, Deno, Bun, browsers).
+ */
+async function computeHmacSha256(secret, message) {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
+    return Array.from(new Uint8Array(signature))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+/**
+ * Constant-time string comparison to prevent timing attacks.
+ */
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return result === 0;
+}
+//# sourceMappingURL=client.js.map