@jasy/cli 1.0.0-alpha.1

package/README.md

@@ -0,0 +1,72 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/jasy-pdf/jasy/main/docs/logo.png" width="120" alt="jasy">
+</p>
+
+<h1 align="center">@jasy/cli</h1>
+
+<p align="center">
+  <b>The terminal for ZUGFeRD &amp; XRechnung. Read, validate and export any e-invoice PDF.</b><br>
+  Headless for scripts and CI, interactive when you want to look. 100% local - no upload, no account.
+</p>
+
+<p align="center"><code>npx @jasy/cli</code> &nbsp;·&nbsp; MIT</p>
+
+---
+
+## Don't believe us. Point it at your own invoice.
+
+```bash
+npx @jasy/cli validate ./your-invoice.pdf
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/jasy-pdf/jasy/main/docs/validate.png" width="430" alt="jasy validate: VALID">
+</p>
+
+That `✓` runs the **same official KoSIT Schematron + veraPDF the big tools use** - the EN 16931 **and**
+the German XRechnung (BR-DE) rules, plus PDF/A-3. It exits non-zero when invalid, so it drops straight
+into CI. Your file, your terminal, in seconds.
+
+> Java has **Mustang**. PHP has **horstoeko**. Python has **factur-x**.
+> Node had nothing. Now it has jasy.
+
+## Everything it does
+
+```bash
+jasy read    invoice.pdf            # identify + show: parties, line items, totals (CII and UBL)
+jasy validate invoice.pdf           # EN 16931 + XRechnung + PDF/A  (exit 1 if invalid)
+jasy export  invoice.pdf -o x.xlsx  # read it back to JSON, TXT or Excel
+jasy                                # the interactive terminal: open, inspect, export
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/jasy-pdf/jasy/main/docs/read.png" width="520" alt="the jasy terminal">
+</p>
+
+Reads **CII and UBL**, real third-party invoices included - not just invoices we made ourselves.
+
+## The full ISO PDF/A check, optional and guided
+
+Structural PDF/A-3 checks run built-in. For the **complete** ISO 19005 verdict, jasy wires up the
+official **veraPDF** for you - no account, into `~/.jasy/verapdf`:
+
+```bash
+jasy verapdf            # a doctor: is Java here? is veraPDF here? what to run if not
+jasy verapdf --install  # downloads + installs it locally (the one requirement is a Java runtime)
+```
+
+Once present, `jasy validate` adds the full ISO check automatically. It is never a gate - your own
+structural checks carry the everyday case.
+
+## Under the hood
+
+- **Schematron, local** - the official EN-16931 + XRechnung rules run via saxon-js (the real XSLT, in
+  pure JS). No upload, DSGVO-safe.
+- **Excel by hand** - the `.xlsx` is a ZIP we build ourselves, deflated with our own writer and CRC32.
+- **Reads multi-file PDFs** - pulls the right e-invoice XML out even when a tool embedded its own JSON too.
+- Generates with [`@jasy/zugferd`](https://www.npmjs.com/package/@jasy/zugferd) on the hand-rolled
+  [`@jasy/pdf`](https://www.npmjs.com/package/@jasy/pdf) engine.
+
+---
+
+<p align="center">MIT &nbsp;·&nbsp; part of <a href="https://github.com/jasy-pdf/jasy">jasy</a></p>

package/assets/jasy.txt

@@ -0,0 +1,23 @@
+                    ▄                                          
+                    █████▄                                     
+           ▄         ████████▄                                 
+           ██        ███████████▄                              
+           ████▄      ██████████████▄                          
+            ███████▄   ▀███████████████▄             ▄██▄      
+             ██████████▄    ▀█████████████         ████████▄   
+              ██████████████▄    ▀█████████       ██████████▄  
+               ██████████████████▄  ▀███████     ████████▀ ▀██▄
+▀██▄            ████████████████████▄ ▀█████    ███████        
+ ▀███▄           █████████████████████▄ ▀▀███▄▄███████         
+  ▀█████▄         █████████████████████▒▒   ▀▀███████          
+    ███████▄       ▀████████████████████▒▒▒▒ ███████           
+     ▀████████▄      ▀███████████████████▒▒▒▒██████            
+       ▀██████████▄   ▒▒▒▒▒▒▒█████████████▒████████            
+         ▀██████████▄ ▄███▒▒▒▒▒▒▒▒▒███████████████             
+           ▀█████████████████▒▒▒▒▒▒▒▒▒▒▒▒█████████             
+             ▀██████████████████▒▒▒▒▒████████████              
+               ▀█████████████████▒███████████████              
+                 ▀█████████████  ███████████████               
+                   ▀█████████▀    ▀█████████▀ ▀█               
+                    ▀████▀            ▀████                    
+                      ▀                  ▀                     

package/assets/validation/README.md

@@ -0,0 +1,21 @@
+# Vendored validation rules
+
+The official **EN 16931 / XRechnung Schematron** business rules, compiled to SaxonJS SEF
+(`.sef.json`, gzipped) so the CLI validates invoices **locally** via `saxon-js` — no upload, DSGVO-safe.
+This covers the XML conformance (the legally decisive part); full ISO 19005 (PDF/A) is the optional
+veraPDF adapter (`jasy verapdf`), with our own structural checks (`core/pdfa.ts`) as the default.
+
+`validate.ts` picks the rule set from what `detect()` found. **XRechnung is a CIUS on top of EN 16931**,
+so its files carry only the BR-DE delta — an XRechnung is validated against the EN 16931 base **and**
+the XRechnung rules, and the findings are merged.
+
+| File                        | Rules                                             | Upstream                                                                                                                                                   |
+| --------------------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `en16931-cii.sef.json.gz`   | EN 16931 — UN/CEFACT **CII** (ZUGFeRD / Factur-X) | [ConnectingEurope/eInvoicing-EN16931](https://github.com/ConnectingEurope/eInvoicing-EN16931) (Apache-2.0), `cii/xslt/EN16931-CII-validation.xslt`         |
+| `en16931-ubl.sef.json.gz`   | EN 16931 — OASIS **UBL** (PEPPOL)                 | same repo, `ubl/xslt/EN16931-UBL-validation.xslt`                                                                                                          |
+| `xrechnung-cii.sef.json.gz` | XRechnung 3.0 BR-DE delta — **CII**               | [itplr-kosit/xrechnung-schematron](https://github.com/itplr-kosit/xrechnung-schematron) v2.5.0 (Apache-2.0), `schematron/cii/XRechnung-CII-validation.xsl` |
+| `xrechnung-ubl.sef.json.gz` | XRechnung 3.0 BR-DE delta — **UBL**               | same release, `schematron/ubl/XRechnung-UBL-validation.xsl`                                                                                                |
+
+**To refresh / add a profile:** fetch the upstream `.xslt`/`.xsl`, then
+`xslt3 -xsl:<file> -export:<out>.sef.json -nogo` and `gzip` the result into this folder.
+(`xslt3` is the SaxonJS compiler, a devDependency.)

package/dist/commands/export.d.ts

@@ -0,0 +1 @@
+export declare function exportCommand(args: string[]): void;

package/dist/commands/export.js

@@ -0,0 +1,63 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve, extname } from "node:path";
+import { readInvoice } from "../core/read.js";
+import { exportInvoice } from "../core/export.js";
+// `jasy export <file> [-f json|txt|xlsx] [-o out]` - read a ZUGFeRD/XRechnung PDF or XML and write the
+// invoice out as JSON, plain text or a spreadsheet. Format comes from -f, else the -o extension, else json.
+const FORMATS = {
+    json: "json",
+    txt: "txt",
+    text: "txt",
+    xlsx: "xlsx",
+    excel: "xlsx",
+};
+export function exportCommand(args) {
+    var _a, _b, _c;
+    let file;
+    let out;
+    let fmtArg;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "-f" || a === "--format")
+            fmtArg = args[++i];
+        else if (a === "-o" || a === "--out")
+            out = args[++i];
+        else if (!a.startsWith("-") && !file)
+            file = a;
+    }
+    if (!file) {
+        console.error("usage: jasy export <file.pdf|file.xml> [-f json|txt|xlsx] [-o out]");
+        process.exitCode = 1;
+        return;
+    }
+    const format = (_b = (_a = FORMATS[fmtArg !== null && fmtArg !== void 0 ? fmtArg : ""]) !== null && _a !== void 0 ? _a : FORMATS[out ? extname(out).slice(1) : ""]) !== null && _b !== void 0 ? _b : "json";
+    if (format === "xlsx" && !out) {
+        console.error("✗ xlsx is binary - give an output path with -o <file.xlsx>");
+        process.exitCode = 1;
+        return;
+    }
+    const base = (_c = process.env.INIT_CWD) !== null && _c !== void 0 ? _c : process.cwd();
+    let bytes;
+    try {
+        bytes = readFileSync(resolve(base, file));
+    }
+    catch (e) {
+        console.error(`✗ could not read ${file}: ${e.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    const r = readInvoice(bytes);
+    if (!r.invoice || !r.totals) {
+        console.error(`✗ could not parse the invoice (${r.meta.syntax}/${r.meta.profile})`);
+        process.exitCode = 1;
+        return;
+    }
+    const data = exportInvoice(r.invoice, r.totals, format);
+    if (out) {
+        writeFileSync(resolve(base, out), data);
+        console.log(`✓ wrote ${format} → ${out}`);
+    }
+    else {
+        process.stdout.write(data); // json/txt are strings (xlsx required -o above)
+    }
+}

package/dist/commands/read.d.ts

@@ -0,0 +1 @@
+export declare function readCommand(args: string[]): void;

package/dist/commands/read.js

@@ -0,0 +1,73 @@
+import { writeFileSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { readInvoiceFile } from "../core/read.js";
+import { describeInvoice } from "../core/detect.js";
+// `jasy read <file> [--xml] [-o out]` - read a ZUGFeRD / XRechnung PDF (or raw XML) and show the actual
+// invoice (number, parties, lines, totals) for humans, or dump / save the embedded XML.
+const tty = process.stdout.isTTY;
+const paint = (c, s) => (tty ? `\x1b[${c}m${s}\x1b[0m` : s);
+const bold = (s) => paint("1", s);
+const dim = (s) => paint("2", s);
+const money = (n) => n.toFixed(2);
+export function readCommand(args) {
+    var _a, _b;
+    let file;
+    let out;
+    let dumpXml = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--xml")
+            dumpXml = true;
+        else if (a === "-o" || a === "--out")
+            out = args[++i];
+        else if (!a.startsWith("-") && !file)
+            file = a;
+    }
+    if (!file) {
+        console.error("usage: jasy read <file.pdf|file.xml> [--xml] [-o out.xml]");
+        process.exitCode = 1;
+        return;
+    }
+    // resolve against where the user actually stood - pnpm scripts cd into the package dir
+    const base = (_a = process.env.INIT_CWD) !== null && _a !== void 0 ? _a : process.cwd();
+    let r;
+    try {
+        r = readInvoiceFile(resolve(base, file));
+    }
+    catch (e) {
+        console.error(`✗ could not read ${file}: ${e.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (out) {
+        writeFileSync(resolve(base, out), r.xml);
+        console.log(`✓ wrote ${r.xml.length} bytes of XML → ${out}`);
+        return;
+    }
+    if (dumpXml) {
+        process.stdout.write(r.xml.endsWith("\n") ? r.xml : r.xml + "\n");
+        return;
+    }
+    console.log(`\n✓ ${bold(basename(file))}  ${dim("·")}  ${describeInvoice(r.meta)}\n`);
+    const inv = r.invoice;
+    if (inv && r.totals) {
+        console.log(`  invoice    ${bold(inv.number)}`);
+        console.log(`  date       ${inv.issueDate}${inv.dueDate ? dim(`   due ${inv.dueDate}`) : ""}`);
+        console.log(`  from       ${inv.seller.name}`);
+        console.log(`  to         ${inv.buyer.name}\n`);
+        inv.lines.forEach((l, i) => {
+            const left = `  ${l.quantity} ${l.unit}  ${l.name}`;
+            console.log(left.padEnd(48) + money(r.totals.lineNets[i]).padStart(12));
+        });
+        const t = r.totals;
+        console.log("  " + dim("─".repeat(58)));
+        console.log(`  ${dim("net")} ${money(t.taxBasisTotal)}   ${dim("VAT")} ${money(t.taxTotal)}   ${bold(`total ${money(t.grandTotal)} ${inv.currency}`)}`);
+        console.log(`\n  ${dim("→ --xml print the XML · -o <file> save it · jasy validate <file>")}`);
+    }
+    else {
+        console.log(`  source     ${r.isPdf ? "PDF - embedded XML extracted" : "raw XML"}`);
+        console.log(`  guideline  ${(_b = r.meta.guideline) !== null && _b !== void 0 ? _b : "-"}`);
+        console.log(`  XML        ${r.xml.length} bytes`);
+        console.log(`\n  ${dim("→ --xml print the XML · -o <file> save it")}`);
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1 @@
+export declare function validateCommand(args: string[]): void;

package/dist/commands/validate.js

@@ -0,0 +1,102 @@
+import { readFileSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { readInvoice } from "../core/read.js";
+import { describeInvoice } from "../core/detect.js";
+import { validateInvoiceXml, profileFor } from "../core/validate.js";
+import { checkPdfA3 } from "../core/pdfa.js";
+import { findVerapdf, runVeraPdf } from "../core/verapdf.js";
+// `jasy validate <file> [-v]` - runs the full local check (EN 16931 business rules + structural
+// PDF/A-3) on a ZUGFeRD/XRechnung PDF or raw XML, prints a report, and exits non-zero when invalid
+// (so it slots into scripts/CI). Same UI-agnostic core as the TUI.
+const tty = process.stdout.isTTY;
+const paint = (code, s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : s);
+const green = (s) => paint("32", s);
+const red = (s) => paint("31", s);
+const dim = (s) => paint("2", s);
+const bold = (s) => paint("1", s);
+export function validateCommand(args) {
+    var _a, _b;
+    const file = args.find((a) => !a.startsWith("-"));
+    const verbose = args.includes("-v") || args.includes("--verbose");
+    if (!file) {
+        console.error("usage: jasy validate <file.pdf|file.xml> [-v]");
+        process.exitCode = 1;
+        return;
+    }
+    const base = (_a = process.env.INIT_CWD) !== null && _a !== void 0 ? _a : process.cwd();
+    let bytes;
+    try {
+        bytes = readFileSync(resolve(base, file));
+    }
+    catch (e) {
+        console.error(red(`✗ could not read ${file}: ${e.message}`));
+        process.exitCode = 1;
+        return;
+    }
+    const read = readInvoice(bytes);
+    // XML business rules (Schematron) - EN 16931, plus the XRechnung BR-DE delta when it's an XRechnung.
+    // The rule set is picked automatically from what detect() found (syntax + CIUS).
+    let rules = null;
+    if (read.meta.syntax !== "unknown") {
+        try {
+            rules = validateInvoiceXml(read.xml, profileFor(read.meta));
+        }
+        catch (_c) {
+            rules = null;
+        }
+    }
+    const pdfa = read.isPdf ? checkPdfA3(bytes) : null;
+    const label = (s) => s.padEnd(20);
+    console.log(`\n  ${bold(basename(file))}  ${dim("·")}  ${describeInvoice(read.meta)}\n`);
+    // business rules
+    if (rules) {
+        const n = rules.errors.length;
+        const name = rules.profile.startsWith("xrechnung") ? "XRechnung rules" : "EN 16931 rules";
+        console.log(`  ${label(name)}${rules.valid ? green("✓ valid") : red(`✗ ${n} error${n === 1 ? "" : "s"}`)}`);
+        for (const e of rules.errors)
+            console.log(`    ${red("✗")} ${e.id ? bold(`[${e.id}]`) + " " : ""}${e.text}`);
+        if (verbose)
+            for (const w of rules.warnings)
+                console.log(`    ${dim(`! ${w.id ? `[${w.id}] ` : ""}${w.text}`)}`);
+    }
+    else {
+        console.log(`  ${label("business rules")}${dim("n/a (unrecognised XML)")}`);
+    }
+    // PDF/A-3 structure
+    if (pdfa) {
+        const passed = pdfa.checks.filter((c) => c.ok).length;
+        const tot = pdfa.checks.length;
+        console.log(`  ${label("PDF/A-3 structure")}${pdfa.ok ? green(`✓ ${passed}/${tot}`) : red(`✗ ${passed}/${tot}`)}`);
+        for (const c of pdfa.checks) {
+            if (!c.ok || verbose)
+                console.log(`    ${c.ok ? green("✓") : red("✗")} ${c.label}${c.detail ? dim(`  ${c.detail}`) : ""}`);
+        }
+    }
+    else {
+        console.log(`  ${label("PDF/A-3 structure")}${dim("n/a (raw XML)")}`);
+    }
+    // full ISO 19005 (PDF/A) via veraPDF - only when installed; never blocks, just adds the official seal
+    let vera = null;
+    if (read.isPdf && findVerapdf()) {
+        try {
+            vera = runVeraPdf(resolve(base, file));
+        }
+        catch (_d) {
+            vera = null;
+        }
+    }
+    if (vera) {
+        const n = (_b = vera.failedRules) !== null && _b !== void 0 ? _b : vera.failures.length;
+        console.log(`  ${label("PDF/A (veraPDF)")}${vera.ok ? green("✓ compliant") : red(`✗ ${n} failed`)}`);
+        if (!vera.ok)
+            for (const f of vera.failures)
+                console.log(`    ${red("✗")} ISO clause ${f.clause}${dim(`  (${f.failedChecks} checks)`)}`);
+    }
+    else if (read.isPdf) {
+        console.log(`  ${label("PDF/A (veraPDF)")}${dim("n/a - `jasy verapdf --install` for the full ISO check")}`);
+    }
+    const ok = (!rules || rules.valid) && (!pdfa || pdfa.ok) && (!vera || vera.ok);
+    console.log(`\n  → ${ok ? green(bold("VALID")) : red(bold("INVALID"))}\n`);
+    if (!ok)
+        process.exitCode = 1;
+}

package/dist/commands/verapdf.d.ts

@@ -0,0 +1 @@
+export declare function verapdfCommand(args: string[]): Promise<void>;

package/dist/commands/verapdf.js

@@ -0,0 +1,96 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { resolve } from "node:path";
+import { detectTools, installVeraPdf, runVeraPdf, findVerapdf } from "../core/verapdf.js";
+// `jasy verapdf` - a guided doctor for the optional full-ISO PDF/A validator:
+//   jasy verapdf            explain what veraPDF is + show Java / veraPDF status (✓ / ✗) + next steps
+//   jasy verapdf --install  download + install it into ~/.jasy/verapdf (no admin, no account)
+//   jasy verapdf <file>     validate a PDF with veraPDF and print the report
+const tty = process.stdout.isTTY;
+const paint = (c, s) => (tty ? `\x1b[${c}m${s}\x1b[0m` : s);
+const green = (s) => paint("32", s);
+const red = (s) => paint("31", s);
+const dim = (s) => paint("2", s);
+const bold = (s) => paint("1", s);
+export function verapdfCommand(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (args.includes("--install"))
+            return install();
+        const file = args.find((a) => !a.startsWith("-"));
+        if (file)
+            return validateFile(file);
+        doctor();
+    });
+}
+function doctor() {
+    var _a, _b;
+    const t = detectTools();
+    console.log(`
+  ${bold("veraPDF")} - the official open-source PDF/A validator (PDF Association).
+  It checks a PDF against the full ISO 19005 (PDF/A) standard - the exact
+  conformance a ZUGFeRD / Factur-X invoice PDF must meet. Runs 100% locally;
+  your invoice never leaves the machine. Free, no account.
+`);
+    const row = (label, ok, detail) => console.log(`  ${label.padEnd(11)}${ok ? green("✓ " + detail) : red("✗ " + detail)}`);
+    row("Java", !!t.java, (_a = t.java) !== null && _a !== void 0 ? _a : "not found");
+    row("veraPDF", !!t.verapdf, t.verapdf ? `${t.verapdf}  ${dim((_b = t.verapdfPath) !== null && _b !== void 0 ? _b : "")}` : "not found");
+    console.log("");
+    if (!t.java) {
+        console.log(`  ${dim("Java is required - veraPDF is a Java app. Install a JRE 11+:")}`);
+        console.log(`    ${dim("macOS")}   brew install --cask temurin`);
+        console.log(`    ${dim("Ubuntu")}  sudo apt install default-jre`);
+        console.log(`    ${dim("Windows")} winget install EclipseAdoptium.Temurin.21.JRE`);
+    }
+    if (!t.verapdf) {
+        console.log(`  ${dim("Then install veraPDF (no admin, into ~/.jasy/verapdf):")}  ${bold("jasy verapdf --install")}`);
+    }
+    else if (t.java) {
+        console.log(`  ${green("Ready.")} ${dim("`jasy validate <file>` now adds the full ISO PDF/A check automatically.")}`);
+    }
+}
+function install() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const bin = yield installVeraPdf((s) => console.log(`  ${dim(s)}`));
+            console.log(`  ${green("✓ veraPDF installed")}  ${dim(bin)}`);
+            console.log(`  ${dim("`jasy validate <file>` now runs the full ISO PDF/A check.")}`);
+        }
+        catch (e) {
+            console.error(`  ${red("✗ " + e.message)}`);
+            process.exitCode = 1;
+        }
+    });
+}
+function validateFile(file) {
+    var _a, _b, _c;
+    if (!findVerapdf()) {
+        console.error(`  ${red("✗ veraPDF is not installed")} - run ${bold("jasy verapdf --install")}`);
+        process.exitCode = 1;
+        return;
+    }
+    const base = (_a = process.env.INIT_CWD) !== null && _a !== void 0 ? _a : process.cwd();
+    try {
+        const r = runVeraPdf(resolve(base, file));
+        const head = r.ok
+            ? green("✓ compliant")
+            : red(`✗ ${(_b = r.failedRules) !== null && _b !== void 0 ? _b : r.failures.length} rule(s) failed`);
+        console.log(`\n  ${(_c = r.profile) !== null && _c !== void 0 ? _c : "PDF/A"}   ${head}`);
+        for (const f of r.failures) {
+            const n = f.failedChecks;
+            console.log(`    ${red("✗")} ISO clause ${bold(f.clause)}  ${dim(`(${n} check${n === 1 ? "" : "s"})`)}`);
+        }
+        if (!r.ok)
+            process.exitCode = 1;
+    }
+    catch (e) {
+        console.error(`  ${red("✗ " + e.message)}`);
+        process.exitCode = 1;
+    }
+}

package/dist/core/detect.d.ts

@@ -0,0 +1,11 @@
+export type Syntax = "CII" | "UBL" | "unknown";
+export type Profile = "en16931" | "xrechnung" | "unknown";
+export interface InvoiceMeta {
+    syntax: Syntax;
+    profile: Profile;
+    /** The raw guideline / customization identifier (BT-24). */
+    guideline: string | null;
+}
+export declare function detectInvoice(xml: string): InvoiceMeta;
+/** A short human label, e.g. "ZUGFeRD · EN 16931 (CII)", "EN 16931 (UBL)" or "XRechnung (CII)". */
+export declare function describeInvoice(meta: InvoiceMeta): string;

package/dist/core/detect.js

@@ -0,0 +1,33 @@
+// Identifies an e-invoice XML at a glance: which syntax (UN/CEFACT CII vs OASIS UBL) and which
+// profile (plain EN16931 vs the German XRechnung CIUS). Pure tag/regex inspection - no full parse
+// needed (that comes later). Lets the CLI say "ZUGFeRD EN16931 (CII)" before doing anything heavy.
+export function detectInvoice(xml) {
+    var _a, _b, _c, _d;
+    const syntax = /<(?:rsm:)?CrossIndustryInvoice/.test(xml)
+        ? "CII"
+        : /<Invoice\b[^>]*urn:oasis:names:specification:ubl/.test(xml) ||
+            /<(?:\w+:)?Invoice\b/.test(xml)
+            ? "UBL"
+            : "unknown";
+    // BT-24: CII carries it in GuidelineSpecified…/ram:ID, UBL in cbc:CustomizationID.
+    const guideline = (_d = (_b = (_a = xml.match(/GuidelineSpecifiedDocumentContextParameter>\s*<(?:ram:)?ID>([^<]+)</)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : (_c = xml.match(/<(?:cbc:)?CustomizationID>([^<]+)</)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : null;
+    const profile = !guideline
+        ? "unknown"
+        : /xrechnung/i.test(guideline)
+            ? "xrechnung"
+            : /en16931:2017/.test(guideline)
+                ? "en16931"
+                : "unknown";
+    return { syntax, profile, guideline };
+}
+/** A short human label, e.g. "ZUGFeRD · EN 16931 (CII)", "EN 16931 (UBL)" or "XRechnung (CII)". */
+export function describeInvoice(meta) {
+    if (meta.profile === "xrechnung")
+        return `XRechnung (${meta.syntax})`;
+    if (meta.profile === "en16931") {
+        // ZUGFeRD / Factur-X is the CII flavour; a bare EN 16931 UBL is PEPPOL territory - don't mislabel it
+        const family = meta.syntax === "CII" ? "ZUGFeRD · " : "";
+        return `${family}EN 16931 (${meta.syntax})`;
+    }
+    return `unknown profile (${meta.syntax})`;
+}

package/dist/core/export.d.ts

@@ -0,0 +1,10 @@
+import type { Invoice, ComputedInvoice } from "@jasy/zugferd";
+export type ExportFormat = "json" | "txt" | "xlsx";
+/** Full invoice model + a computed totals block, pretty-printed. */
+export declare function exportJson(inv: Invoice, t: ComputedInvoice): string;
+/** A plain-text receipt - no ANSI, safe to pipe or save. */
+export declare function exportText(inv: Invoice, t: ComputedInvoice): string;
+/** A minimal single-sheet .xlsx with the invoice header, line items and totals. */
+export declare function exportXlsx(inv: Invoice, t: ComputedInvoice): Buffer;
+/** Export to the requested format - string for json/txt, Buffer for the binary xlsx. */
+export declare function exportInvoice(inv: Invoice, t: ComputedInvoice, format: ExportFormat): string | Buffer;