@beliq/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) beliq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# @beliq/sdk
+
+Official Node/TypeScript SDK for the [beliq](https://beliq.eu) e-invoicing compliance API. Generate, validate, parse, and convert EN 16931 invoices (XRechnung, ZUGFeRD, Factur-X, Peppol BIS) against authority-pinned, nightly-drift-checked rules.
+
+beliq produces and checks the compliant document. Transmission (Peppol, PDP, KSeF, SDI), archiving, and tax-authority reporting stay with your access point.
+
+## Install
+
+```bash
+npm install @beliq/sdk
+```
+
+Requires Node >= 20.15. Ships ESM and CommonJS builds with bundled type declarations.
+
+## Quick start
+
+```ts
+import { Beliq } from '@beliq/sdk';
+
+const beliq = new Beliq({ apiKey: process.env.BELIQ_API_KEY! });
+
+// Account, plan, and quota context (no quota cost).
+const account = await beliq.me();
+
+// Generate an XRechnung document from an EN 16931 invoice object.
+const generated = await beliq.generate({
+  standard: 'xrechnung',
+  verify: true,
+  invoice: {
+    number: 'INV-2026-001',
+    issueDate: '2026-01-15',
+    currencyCode: 'EUR',
+    seller: { name: 'Seller GmbH', address: { city: 'Berlin', postalCode: '10115', countryCode: 'DE' } },
+    buyer: { name: 'Buyer GmbH', address: { city: 'Munich', postalCode: '80331', countryCode: 'DE' } },
+    lines: [{ description: 'Consulting', quantity: 10, unitCode: 'HUR', unitPrice: 100, lineTotal: 1000, vatRate: 19, vatCategoryCode: 'S' }],
+    totalNetAmount: 1000,
+    totalTaxAmount: 190,
+    totalGrossAmount: 1190,
+  },
+});
+console.log(generated.xml, generated.meta.schematronVersion);
+
+// Validate any document against authority-pinned rules.
+const result = await beliq.validate(generated.xml!, { format: 'auto' });
+if (!result.valid) {
+  for (const issue of result.errors) console.log(issue.ruleId, issue.message);
+}
+```
+
+## Authentication
+
+Create an API key in the beliq dashboard under API Keys, then pass it to the client:
+
+```ts
+new Beliq({ apiKey: 'blq_...' });                 // sends X-API-Key (default)
+new Beliq({ apiKey: 'blq_...', auth: 'bearer' });  // sends Authorization: Bearer
+new Beliq({ apiKey: 'blq_...', baseUrl: 'https://staging.beliq.eu' });
+```
+
+## API
+
+| Method | Endpoint | Input | Returns |
+|---|---|---|---|
+| `me()` | GET /v1/me | none | `AccountInfo` (no quota cost) |
+| `generate(input)` | POST /v1/generate | EN 16931 invoice object | `{ contentType, bytes, xml?, meta }` |
+| `validate(document, options?)` | POST /v1/validate | XML or PDF | `ValidationResult` |
+| `parse(document, options?)` | POST /v1/parse | XML or PDF | `ParseResult` |
+| `convert(document, options)` | POST /v1/convert | XML or PDF | `{ contentType, bytes, meta }` |
+
+`document` accepts a `string`, `Uint8Array`, `Buffer`, `ArrayBuffer`, or typed array. The content type is sniffed from the bytes (PDF vs XML) unless you pass `options.contentType`. `generate` and `convert` return raw document bytes plus the response-header metadata (`schematronVersion`, `pdfKind`, `sourceFormat`/`targetFormat`, `lostElements`, `conversionTools`); for an XML output, `generate` also decodes `xml`.
+
+Every option enum is typed from the OpenAPI spec, so wrong values fail at compile time. Errors throw `BeliqApiError` with a typed `.code`, HTTP `.status`, and any `.details`:
+
+```ts
+import { BeliqApiError } from '@beliq/sdk';
+
+try {
+  await beliq.validate('not xml');
+} catch (err) {
+  if (err instanceof BeliqApiError) console.log(err.code, err.status, err.message);
+}
+```
+
+## Types stay in sync with the API
+
+`src/generated/schema.ts` is generated from a vendored copy of the published OpenAPI spec (`openapi.json`).
+
+```bash
+npm run sync:spec      # refresh openapi.json from beliq-api / the live spec
+npm run gen:types      # regenerate src/generated/schema.ts
+npm run openapi:check  # CI drift guard: fails if the generated types are stale
+```
+
+The vendored spec is committed so builds are reproducible; nothing is fetched from the network at build time.
+
+## Development
+
+```bash
+npm install
+npm run build       # tsup: dual ESM + CJS + d.ts
+npm run typecheck
+npm run lint
+npm test            # unit tests (no network)
+BELIQ_API_KEY=blq_xxx npm run test:integration   # hits the live API; draws quota
+```
+
+## Publishing
+
+Released to npm as [`@beliq/sdk`](https://www.npmjs.com/package/@beliq/sdk). Releases run from `.github/workflows/release.yml` via npm Trusted Publishing (OIDC, with provenance): push a `v*.*.*` tag to publish. No npm token is stored in the repo.
+
+## License
+
+MIT

package/dist/constants-bWOXCmJD.d.cts

@@ -0,0 +1,22 @@
+type PlainObject = Record<string, unknown>;
+declare function isPlainObject(value: unknown): value is PlainObject;
+/** Deep-merge `source` into `target` (source wins). Arrays and scalars overwrite. */
+declare function mergeDeep(target: PlainObject, source: PlainObject): PlainObject;
+/** Drop undefined/empty entries so optional query params are omitted, not sent blank. */
+declare function compactQuery(query: PlainObject): PlainObject;
+/** Document bytes a caller may pass to validate/parse/convert. */
+type DocumentInput = string | Uint8Array | ArrayBuffer | ArrayBufferView;
+declare function toBytes(input: DocumentInput): Uint8Array;
+declare function decodeUtf8(bytes: Uint8Array): string;
+/** Sniff `application/pdf` vs `application/xml` from the leading bytes. */
+declare function sniffContentType(bytes: Uint8Array): string;
+
+declare const DEFAULT_BASE_URL = "https://api.beliq.eu";
+declare const LIVE_GENERATE_STANDARDS: readonly ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+declare const LIVE_PROFILES: readonly ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+declare const LIVE_VALIDATE_FORMATS: readonly ["auto", "cii", "ubl"];
+declare const LIVE_PARSE_FORMATS: readonly ["auto", "cii", "ubl"];
+declare const LIVE_CONVERT_SOURCE_FORMATS: readonly ["auto", "cii", "ubl", "zugferd", "facturx", "xrechnung", "peppol-bis"];
+declare const LIVE_CONVERT_TARGET_FORMATS: readonly ["cii", "ubl", "zugferd", "facturx", "xrechnung", "peppol-bis"];
+
+export { DEFAULT_BASE_URL as D, LIVE_CONVERT_SOURCE_FORMATS as L, type PlainObject as P, type DocumentInput as a, LIVE_CONVERT_TARGET_FORMATS as b, LIVE_GENERATE_STANDARDS as c, LIVE_PARSE_FORMATS as d, LIVE_PROFILES as e, LIVE_VALIDATE_FORMATS as f, compactQuery as g, decodeUtf8 as h, isPlainObject as i, mergeDeep as m, sniffContentType as s, toBytes as t };

package/dist/constants-bWOXCmJD.d.ts

@@ -0,0 +1,22 @@
+type PlainObject = Record<string, unknown>;
+declare function isPlainObject(value: unknown): value is PlainObject;
+/** Deep-merge `source` into `target` (source wins). Arrays and scalars overwrite. */
+declare function mergeDeep(target: PlainObject, source: PlainObject): PlainObject;
+/** Drop undefined/empty entries so optional query params are omitted, not sent blank. */
+declare function compactQuery(query: PlainObject): PlainObject;
+/** Document bytes a caller may pass to validate/parse/convert. */
+type DocumentInput = string | Uint8Array | ArrayBuffer | ArrayBufferView;
+declare function toBytes(input: DocumentInput): Uint8Array;
+declare function decodeUtf8(bytes: Uint8Array): string;
+/** Sniff `application/pdf` vs `application/xml` from the leading bytes. */
+declare function sniffContentType(bytes: Uint8Array): string;
+
+declare const DEFAULT_BASE_URL = "https://api.beliq.eu";
+declare const LIVE_GENERATE_STANDARDS: readonly ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+declare const LIVE_PROFILES: readonly ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+declare const LIVE_VALIDATE_FORMATS: readonly ["auto", "cii", "ubl"];
+declare const LIVE_PARSE_FORMATS: readonly ["auto", "cii", "ubl"];
+declare const LIVE_CONVERT_SOURCE_FORMATS: readonly ["auto", "cii", "ubl", "zugferd", "facturx", "xrechnung", "peppol-bis"];
+declare const LIVE_CONVERT_TARGET_FORMATS: readonly ["cii", "ubl", "zugferd", "facturx", "xrechnung", "peppol-bis"];
+
+export { DEFAULT_BASE_URL as D, LIVE_CONVERT_SOURCE_FORMATS as L, type PlainObject as P, type DocumentInput as a, LIVE_CONVERT_TARGET_FORMATS as b, LIVE_GENERATE_STANDARDS as c, LIVE_PARSE_FORMATS as d, LIVE_PROFILES as e, LIVE_VALIDATE_FORMATS as f, compactQuery as g, decodeUtf8 as h, isPlainObject as i, mergeDeep as m, sniffContentType as s, toBytes as t };

package/dist/helpers.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/helpers.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  LIVE_CONVERT_SOURCE_FORMATS: () => LIVE_CONVERT_SOURCE_FORMATS,
+  LIVE_CONVERT_TARGET_FORMATS: () => LIVE_CONVERT_TARGET_FORMATS,
+  LIVE_GENERATE_STANDARDS: () => LIVE_GENERATE_STANDARDS,
+  LIVE_PARSE_FORMATS: () => LIVE_PARSE_FORMATS,
+  LIVE_PROFILES: () => LIVE_PROFILES,
+  LIVE_VALIDATE_FORMATS: () => LIVE_VALIDATE_FORMATS,
+  buildRequest: () => buildRequest,
+  compactQuery: () => compactQuery,
+  decodeUtf8: () => decodeUtf8,
+  isPlainObject: () => isPlainObject,
+  mergeDeep: () => mergeDeep,
+  sniffContentType: () => sniffContentType,
+  toBytes: () => toBytes
+});
+module.exports = __toCommonJS(helpers_exports);
+
+// src/internal.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeDeep(target, source) {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (isPlainObject(value) && isPlainObject(out[key])) {
+      out[key] = mergeDeep(out[key], value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function compactQuery(query) {
+  const out = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === "") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function toBytes(input) {
+  if (typeof input === "string") return new TextEncoder().encode(input);
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  throw new TypeError("beliq: document must be a string, Uint8Array, ArrayBuffer, or typed array");
+}
+function decodeUtf8(bytes) {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+var PDF_MAGIC = [37, 80, 68, 70, 45];
+function sniffContentType(bytes) {
+  const isPdf = bytes.length >= PDF_MAGIC.length && PDF_MAGIC.every((b, i) => bytes[i] === b);
+  return isPdf ? "application/pdf" : "application/xml";
+}
+
+// src/buildRequest.ts
+function isFacturxFamily(standardOrFormat) {
+  return standardOrFormat === "facturx" || standardOrFormat === "zugferd";
+}
+function withAdvancedQuery(query, advanced) {
+  const base = compactQuery(query);
+  const merged = advanced && Object.keys(advanced).length > 0 ? mergeDeep(base, advanced) : base;
+  return merged;
+}
+function buildRequest(params) {
+  switch (params.operation) {
+    case "me":
+      return { method: "GET", path: "/v1/me", outputKind: "json" };
+    case "generate": {
+      const body = {
+        standard: params.standard,
+        output: params.output ?? "xml",
+        invoice: params.invoice ?? {}
+      };
+      if (params.profile) body.profile = params.profile;
+      if (params.facturxProfile && isFacturxFamily(params.standard)) {
+        body.facturxProfile = params.facturxProfile;
+      }
+      if (typeof params.verify === "boolean") body.verify = params.verify;
+      if (params.template) body.template = params.template;
+      if (params.pdfTemplateId) body.pdfTemplateId = params.pdfTemplateId;
+      const merged = params.advanced && Object.keys(params.advanced).length > 0 ? mergeDeep(body, params.advanced) : body;
+      return {
+        method: "POST",
+        path: "/v1/generate",
+        jsonBody: merged,
+        contentType: "application/json",
+        outputKind: "binary"
+      };
+    }
+    case "validate": {
+      const query = { format: params.validateFormat };
+      if (typeof params.franceCtc === "boolean") query.franceCtc = params.franceCtc;
+      return {
+        method: "POST",
+        path: "/v1/validate",
+        query: withAdvancedQuery(query, params.advanced),
+        rawBody: params.rawBody,
+        contentType: params.rawContentType ?? "application/xml",
+        outputKind: "json"
+      };
+    }
+    case "parse":
+      return {
+        method: "POST",
+        path: "/v1/parse",
+        query: withAdvancedQuery({ format: params.parseFormat }, params.advanced),
+        rawBody: params.rawBody,
+        contentType: params.rawContentType ?? "application/xml",
+        outputKind: "json"
+      };
+    case "convert": {
+      const query = {
+        sourceFormat: params.sourceFormat,
+        targetFormat: params.targetFormat
+      };
+      if (params.targetProfile && isFacturxFamily(params.targetFormat)) {
+        query.targetProfile = params.targetProfile;
+      }
+      if (typeof params.dropFranceCtcOverlay === "boolean") {
+        query.dropFranceCtcOverlay = params.dropFranceCtcOverlay;
+      }
+      return {
+        method: "POST",
+        path: "/v1/convert",
+        query: withAdvancedQuery(query, params.advanced),
+        rawBody: params.rawBody,
+        contentType: params.rawContentType ?? "application/xml",
+        outputKind: "binary"
+      };
+    }
+  }
+}
+
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://api.beliq.eu";
+var LIVE_GENERATE_STANDARDS = ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+var LIVE_PROFILES = ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+var LIVE_VALIDATE_FORMATS = ["auto", "cii", "ubl"];
+var LIVE_PARSE_FORMATS = ["auto", "cii", "ubl"];
+var LIVE_CONVERT_SOURCE_FORMATS = [
+  "auto",
+  "cii",
+  "ubl",
+  "zugferd",
+  "facturx",
+  "xrechnung",
+  "peppol-bis"
+];
+var LIVE_CONVERT_TARGET_FORMATS = [
+  "cii",
+  "ubl",
+  "zugferd",
+  "facturx",
+  "xrechnung",
+  "peppol-bis"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BASE_URL,
+  LIVE_CONVERT_SOURCE_FORMATS,
+  LIVE_CONVERT_TARGET_FORMATS,
+  LIVE_GENERATE_STANDARDS,
+  LIVE_PARSE_FORMATS,
+  LIVE_PROFILES,
+  LIVE_VALIDATE_FORMATS,
+  buildRequest,
+  compactQuery,
+  decodeUtf8,
+  isPlainObject,
+  mergeDeep,
+  sniffContentType,
+  toBytes
+});

package/dist/helpers.d.cts

@@ -0,0 +1,44 @@
+import { P as PlainObject } from './constants-bWOXCmJD.cjs';
+export { D as DEFAULT_BASE_URL, a as DocumentInput, L as LIVE_CONVERT_SOURCE_FORMATS, b as LIVE_CONVERT_TARGET_FORMATS, c as LIVE_GENERATE_STANDARDS, d as LIVE_PARSE_FORMATS, e as LIVE_PROFILES, f as LIVE_VALIDATE_FORMATS, g as compactQuery, h as decodeUtf8, i as isPlainObject, m as mergeDeep, s as sniffContentType, t as toBytes } from './constants-bWOXCmJD.cjs';
+
+type Operation = 'me' | 'generate' | 'validate' | 'parse' | 'convert';
+/** 'json' => parse the `{ success, data }` envelope; 'binary' => return raw bytes. */
+type OutputKind = 'json' | 'binary';
+type QueryValue = string | number | boolean;
+interface BuildParams {
+    operation: Operation;
+    standard?: string;
+    profile?: string;
+    output?: 'xml' | 'pdf';
+    facturxProfile?: string;
+    invoice?: PlainObject;
+    verify?: boolean;
+    template?: string;
+    pdfTemplateId?: string;
+    rawBody?: Uint8Array;
+    rawContentType?: string;
+    validateFormat?: string;
+    franceCtc?: boolean;
+    parseFormat?: string;
+    sourceFormat?: string;
+    targetFormat?: string;
+    targetProfile?: string;
+    dropFranceCtcOverlay?: boolean;
+    /** Deep-merged into the request body (generate) or query (raw-input ops). */
+    advanced?: PlainObject;
+}
+interface BuiltRequest {
+    method: 'GET' | 'POST';
+    path: string;
+    query?: Record<string, QueryValue>;
+    /** Set for generate (JSON request body). */
+    jsonBody?: PlainObject;
+    /** Set for validate/parse/convert (raw document bytes). */
+    rawBody?: Uint8Array;
+    /** Request content type; absent for GET. */
+    contentType?: string;
+    outputKind: OutputKind;
+}
+declare function buildRequest(params: BuildParams): BuiltRequest;
+
+export { type BuildParams, type BuiltRequest, type Operation, type OutputKind, PlainObject, type QueryValue, buildRequest };

package/dist/helpers.d.ts

@@ -0,0 +1,44 @@
+import { P as PlainObject } from './constants-bWOXCmJD.js';
+export { D as DEFAULT_BASE_URL, a as DocumentInput, L as LIVE_CONVERT_SOURCE_FORMATS, b as LIVE_CONVERT_TARGET_FORMATS, c as LIVE_GENERATE_STANDARDS, d as LIVE_PARSE_FORMATS, e as LIVE_PROFILES, f as LIVE_VALIDATE_FORMATS, g as compactQuery, h as decodeUtf8, i as isPlainObject, m as mergeDeep, s as sniffContentType, t as toBytes } from './constants-bWOXCmJD.js';
+
+type Operation = 'me' | 'generate' | 'validate' | 'parse' | 'convert';
+/** 'json' => parse the `{ success, data }` envelope; 'binary' => return raw bytes. */
+type OutputKind = 'json' | 'binary';
+type QueryValue = string | number | boolean;
+interface BuildParams {
+    operation: Operation;
+    standard?: string;
+    profile?: string;
+    output?: 'xml' | 'pdf';
+    facturxProfile?: string;
+    invoice?: PlainObject;
+    verify?: boolean;
+    template?: string;
+    pdfTemplateId?: string;
+    rawBody?: Uint8Array;
+    rawContentType?: string;
+    validateFormat?: string;
+    franceCtc?: boolean;
+    parseFormat?: string;
+    sourceFormat?: string;
+    targetFormat?: string;
+    targetProfile?: string;
+    dropFranceCtcOverlay?: boolean;
+    /** Deep-merged into the request body (generate) or query (raw-input ops). */
+    advanced?: PlainObject;
+}
+interface BuiltRequest {
+    method: 'GET' | 'POST';
+    path: string;
+    query?: Record<string, QueryValue>;
+    /** Set for generate (JSON request body). */
+    jsonBody?: PlainObject;
+    /** Set for validate/parse/convert (raw document bytes). */
+    rawBody?: Uint8Array;
+    /** Request content type; absent for GET. */
+    contentType?: string;
+    outputKind: OutputKind;
+}
+declare function buildRequest(params: BuildParams): BuiltRequest;
+
+export { type BuildParams, type BuiltRequest, type Operation, type OutputKind, PlainObject, type QueryValue, buildRequest };

package/dist/helpers.js

@@ -0,0 +1,160 @@
+// src/internal.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeDeep(target, source) {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (isPlainObject(value) && isPlainObject(out[key])) {
+      out[key] = mergeDeep(out[key], value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function compactQuery(query) {
+  const out = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === "") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function toBytes(input) {
+  if (typeof input === "string") return new TextEncoder().encode(input);
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  throw new TypeError("beliq: document must be a string, Uint8Array, ArrayBuffer, or typed array");
+}
+function decodeUtf8(bytes) {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+var PDF_MAGIC = [37, 80, 68, 70, 45];
+function sniffContentType(bytes) {
+  const isPdf = bytes.length >= PDF_MAGIC.length && PDF_MAGIC.every((b, i) => bytes[i] === b);
+  return isPdf ? "application/pdf" : "application/xml";
+}
+
+// src/buildRequest.ts
+function isFacturxFamily(standardOrFormat) {
+  return standardOrFormat === "facturx" || standardOrFormat === "zugferd";
+}
+function withAdvancedQuery(query, advanced) {
+  const base = compactQuery(query);
+  const merged = advanced && Object.keys(advanced).length > 0 ? mergeDeep(base, advanced) : base;
+  return merged;
+}
+function buildRequest(params) {
+  switch (params.operation) {
+    case "me":
+      return { method: "GET", path: "/v1/me", outputKind: "json" };
+    case "generate": {
+      const body = {
+        standard: params.standard,
+        output: params.output ?? "xml",
+        invoice: params.invoice ?? {}
+      };
+      if (params.profile) body.profile = params.profile;
+      if (params.facturxProfile && isFacturxFamily(params.standard)) {
+        body.facturxProfile = params.facturxProfile;
+      }
+      if (typeof params.verify === "boolean") body.verify = params.verify;
+      if (params.template) body.template = params.template;
+      if (params.pdfTemplateId) body.pdfTemplateId = params.pdfTemplateId;
+      const merged = params.advanced && Object.keys(params.advanced).length > 0 ? mergeDeep(body, params.advanced) : body;
+      return {
+        method: "POST",
+        path: "/v1/generate",
+        jsonBody: merged,
+        contentType: "application/json",
+        outputKind: "binary"
+      };
+    }
+    case "validate": {
+      const query = { format: params.validateFormat };
+      if (typeof params.franceCtc === "boolean") query.franceCtc = params.franceCtc;
+      return {
+        method: "POST",
+        path: "/v1/validate",
+        query: withAdvancedQuery(query, params.advanced),
+        rawBody: params.rawBody,
+        contentType: params.rawContentType ?? "application/xml",
+        outputKind: "json"
+      };
+    }
+    case "parse":
+      return {
+        method: "POST",
+        path: "/v1/parse",
+        query: withAdvancedQuery({ format: params.parseFormat }, params.advanced),
+        rawBody: params.rawBody,
+        contentType: params.rawContentType ?? "application/xml",
+        outputKind: "json"
+      };
+    case "convert": {
+      const query = {
+        sourceFormat: params.sourceFormat,
+        targetFormat: params.targetFormat
+      };
+      if (params.targetProfile && isFacturxFamily(params.targetFormat)) {
+        query.targetProfile = params.targetProfile;
+      }
+      if (typeof params.dropFranceCtcOverlay === "boolean") {
+        query.dropFranceCtcOverlay = params.dropFranceCtcOverlay;
+      }
+      return {
+        method: "POST",
+        path: "/v1/convert",
+        query: withAdvancedQuery(query, params.advanced),
+        rawBody: params.rawBody,
+        contentType: params.rawContentType ?? "application/xml",
+        outputKind: "binary"
+      };
+    }
+  }
+}
+
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://api.beliq.eu";
+var LIVE_GENERATE_STANDARDS = ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+var LIVE_PROFILES = ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+var LIVE_VALIDATE_FORMATS = ["auto", "cii", "ubl"];
+var LIVE_PARSE_FORMATS = ["auto", "cii", "ubl"];
+var LIVE_CONVERT_SOURCE_FORMATS = [
+  "auto",
+  "cii",
+  "ubl",
+  "zugferd",
+  "facturx",
+  "xrechnung",
+  "peppol-bis"
+];
+var LIVE_CONVERT_TARGET_FORMATS = [
+  "cii",
+  "ubl",
+  "zugferd",
+  "facturx",
+  "xrechnung",
+  "peppol-bis"
+];
+export {
+  DEFAULT_BASE_URL,
+  LIVE_CONVERT_SOURCE_FORMATS,
+  LIVE_CONVERT_TARGET_FORMATS,
+  LIVE_GENERATE_STANDARDS,
+  LIVE_PARSE_FORMATS,
+  LIVE_PROFILES,
+  LIVE_VALIDATE_FORMATS,
+  buildRequest,
+  compactQuery,
+  decodeUtf8,
+  isPlainObject,
+  mergeDeep,
+  sniffContentType,
+  toBytes
+};