@beliq/sdk 0.1.1 → 0.3.0

package/README.md

@@ -52,22 +52,82 @@ if (!result.valid) {
 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' });
+new Beliq({ apiKey: 'blq_live_...' });                 // sends X-API-Key (default)
+new Beliq({ apiKey: 'blq_live_...', auth: 'bearer' });  // sends Authorization: Bearer
+new Beliq({ apiKey: 'blq_live_...', baseUrl: 'https://staging.beliq.eu' });
 ```
 
+Keys are prefixed `blq_live_` (production, draws your plan quota) or `blq_test_` (sandbox, separate free allowance, watermarked output). `client.livemode` reports the mode from the key prefix before any request; generate and convert results also carry the authoritative `meta.livemode` from the response.
+
+```ts
+const beliq = new Beliq({ apiKey: process.env.BELIQ_API_KEY! });
+if (!beliq.livemode) console.warn('running against the sandbox');
+```
+
+## Timeouts and retries
+
+The client retries transient failures for you, so you do not have to reimplement
+backoff around it.
+
+```ts
+new Beliq({
+  apiKey: 'blq_live_...',
+  timeoutMs: 90_000,  // per-attempt deadline (default)
+  maxRetries: 3,      // extra attempts after the first (default)
+});
+```
+
+Both defaults are exported as `DEFAULT_TIMEOUT_MS` and `DEFAULT_MAX_RETRIES`, so
+you can derive from them instead of repeating the numbers.
+
+Only `429`, `502` and `503` are retried, honouring the server's `Retry-After`
+with jitter. beliq refunds the document's quota unit on a `503`, so a retry never
+costs you a second document.
+
+`504` and this client's own timeout are deliberately **not** retried: both mean
+the work may still be running on beliq's side, so retrying risks producing a
+second document rather than recovering the first.
+
+The default deadline is generous because beliq runs the full Schematron rule set
+over each document, and a generate or validate can legitimately take tens of
+seconds. If you lower it, keep it above the latency you actually see: a deadline
+shorter than the server's own turns completed work into an unknown outcome. Set
+`timeoutMs: 0` to disable it, and `maxRetries: 0` to handle retrying yourself.
+
 ## 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 }` |
+| `generate(input)` | POST /v1/generate | EN 16931 invoice object | `{ contentType, bytes, xml?, sha256?, validationResult?, 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`.
+`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`, `livemode`); for an XML output, `generate` also decodes `xml`.
+
+### Verify-it-yourself seal
+
+Pass `seal: true` to `generate` to also get the document `sha256` and the full `validationResult`. Hashing the returned bytes reproduces the hash, so a recipient can check the document independently:
+
+```ts
+import { createHash } from 'node:crypto';
+
+const doc = await beliq.generate({ standard: 'xrechnung', invoice, seal: true });
+const ok = createHash('sha256').update(doc.bytes).digest('hex') === doc.sha256;
+console.log(doc.validationResult?.valid, doc.meta.rulesetSha256, ok);
+```
+
+### Curated option lists
+
+`LIVE_GENERATE_PRESETS` is the set of public generate targets beliq.eu itself offers, each mapping to the API `standard` (plus `profile`/`facturxProfile`) it needs. NLCIUS is a Peppol BIS profile and lives here rather than in `LIVE_GENERATE_STANDARDS`. Connectors build their dropdowns from these lists.
+
+```ts
+import { LIVE_GENERATE_PRESETS } from '@beliq/sdk';
+
+const nlcius = LIVE_GENERATE_PRESETS.find((p) => p.id === 'nlcius');
+await beliq.generate({ standard: nlcius!.standard, profile: nlcius!.profile, invoice });
+```
 
 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`:
 

package/dist/constants-BZuNzqbV.d.cts

@@ -0,0 +1,85 @@
+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";
+/**
+ * Per-attempt deadline. Sits above the API's own worst case so the server is
+ * always the one to answer: a client that gives up first abandons work that is
+ * still running, and cannot tell whether the document was produced.
+ */
+declare const DEFAULT_TIMEOUT_MS = 90000;
+/** Extra attempts after the first, for 429 / 502 / 503 only. */
+declare const DEFAULT_MAX_RETRIES = 3;
+declare const LIVE_GENERATE_STANDARDS: readonly ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+/** A named generate target: the API `standard` plus the `profile`/`facturxProfile`/`output` it needs. */
+interface GeneratePreset {
+    id: string;
+    label: string;
+    standard: (typeof LIVE_GENERATE_STANDARDS)[number];
+    output: 'xml' | 'pdf';
+    /** API `profile`; omitted lets the engine pick the standard's default. */
+    profile?: string;
+    /** API `facturxProfile`; Factur-X / ZUGFeRD only. */
+    facturxProfile?: string;
+}
+/**
+ * Named generate targets surfaced to end users (connector dropdowns), mirroring
+ * the public set on beliq.eu's own generator. NLCIUS is a Peppol BIS profile,
+ * not a standalone standard, so it is reachable here rather than through
+ * LIVE_GENERATE_STANDARDS or the Factur-X-only LIVE_PROFILES.
+ */
+declare const LIVE_GENERATE_PRESETS: readonly GeneratePreset[];
+/**
+ * The Factur-X granularity values offered publicly. Kept as the flat list the
+ * hybrid-PDF family shares; anything choosing a profile for a specific standard
+ * wants LIVE_PROFILES_BY_STANDARD instead, which is what the API enforces.
+ */
+declare const LIVE_PROFILES: readonly ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+/**
+ * Which profiles each standard accepts, publicly-offered values only.
+ *
+ * `profile` is not a free enum: the engine pins it per standard and answers a
+ * pair outside the table with `422 PROFILE_STANDARD_MISMATCH`
+ * (beliq-engine `app/routes/generate.py`, ALLOWED_PROFILES_FOR_STANDARD). A
+ * surface that offers one flat profile list therefore offers values that cannot
+ * succeed: none of the Factur-X granularity values is legal for `xrechnung` or
+ * `peppol-bis`, and `extended-ctc-fr` is the AFNOR XP Z12-012 France CTC overlay
+ * with no ZUGFeRD-branded counterpart.
+ *
+ * Narrower than the engine's own table in two places, both deliberate: the
+ * `minimum` and `basic` Factur-X profiles are engine-supported but withheld
+ * (FNFE-MPE source gating, mirroring beliq-types SUPPORTED_FACTURX_PROFILE_IDS),
+ * and the standards outside LIVE_GENERATE_STANDARDS are absent entirely.
+ *
+ * `scripts/check-profile-drift.mjs` compares this against the engine's table.
+ */
+declare const LIVE_PROFILES_BY_STANDARD: {
+    readonly xrechnung: readonly ["xrechnung"];
+    readonly 'peppol-bis': readonly ["peppol", "romania-ro-cius", "netherlands-nlcius"];
+    readonly zugferd: readonly ["basicwl", "en16931", "extended"];
+    readonly facturx: readonly ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+};
+/** The profiles a caller may choose for `standard`; empty for an unknown standard. */
+declare function profilesForStandard(standard: string): readonly string[];
+/**
+ * Whether `profile` is legal for `standard`. An unknown standard passes: the API
+ * is the authority on values this list does not carry, and a client-side guess
+ * would refuse a request the server would have accepted.
+ */
+declare function isProfileAllowedForStandard(standard: string, profile: string): boolean;
+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, type GeneratePreset as G, LIVE_CONVERT_SOURCE_FORMATS as L, type PlainObject as P, type DocumentInput as a, LIVE_CONVERT_TARGET_FORMATS as b, LIVE_GENERATE_PRESETS as c, LIVE_GENERATE_STANDARDS as d, LIVE_PARSE_FORMATS as e, LIVE_PROFILES as f, LIVE_PROFILES_BY_STANDARD as g, LIVE_VALIDATE_FORMATS as h, compactQuery as i, decodeUtf8 as j, isPlainObject as k, isProfileAllowedForStandard as l, mergeDeep as m, DEFAULT_MAX_RETRIES as n, DEFAULT_TIMEOUT_MS as o, profilesForStandard as p, sniffContentType as s, toBytes as t };

package/dist/constants-BZuNzqbV.d.ts

@@ -0,0 +1,85 @@
+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";
+/**
+ * Per-attempt deadline. Sits above the API's own worst case so the server is
+ * always the one to answer: a client that gives up first abandons work that is
+ * still running, and cannot tell whether the document was produced.
+ */
+declare const DEFAULT_TIMEOUT_MS = 90000;
+/** Extra attempts after the first, for 429 / 502 / 503 only. */
+declare const DEFAULT_MAX_RETRIES = 3;
+declare const LIVE_GENERATE_STANDARDS: readonly ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+/** A named generate target: the API `standard` plus the `profile`/`facturxProfile`/`output` it needs. */
+interface GeneratePreset {
+    id: string;
+    label: string;
+    standard: (typeof LIVE_GENERATE_STANDARDS)[number];
+    output: 'xml' | 'pdf';
+    /** API `profile`; omitted lets the engine pick the standard's default. */
+    profile?: string;
+    /** API `facturxProfile`; Factur-X / ZUGFeRD only. */
+    facturxProfile?: string;
+}
+/**
+ * Named generate targets surfaced to end users (connector dropdowns), mirroring
+ * the public set on beliq.eu's own generator. NLCIUS is a Peppol BIS profile,
+ * not a standalone standard, so it is reachable here rather than through
+ * LIVE_GENERATE_STANDARDS or the Factur-X-only LIVE_PROFILES.
+ */
+declare const LIVE_GENERATE_PRESETS: readonly GeneratePreset[];
+/**
+ * The Factur-X granularity values offered publicly. Kept as the flat list the
+ * hybrid-PDF family shares; anything choosing a profile for a specific standard
+ * wants LIVE_PROFILES_BY_STANDARD instead, which is what the API enforces.
+ */
+declare const LIVE_PROFILES: readonly ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+/**
+ * Which profiles each standard accepts, publicly-offered values only.
+ *
+ * `profile` is not a free enum: the engine pins it per standard and answers a
+ * pair outside the table with `422 PROFILE_STANDARD_MISMATCH`
+ * (beliq-engine `app/routes/generate.py`, ALLOWED_PROFILES_FOR_STANDARD). A
+ * surface that offers one flat profile list therefore offers values that cannot
+ * succeed: none of the Factur-X granularity values is legal for `xrechnung` or
+ * `peppol-bis`, and `extended-ctc-fr` is the AFNOR XP Z12-012 France CTC overlay
+ * with no ZUGFeRD-branded counterpart.
+ *
+ * Narrower than the engine's own table in two places, both deliberate: the
+ * `minimum` and `basic` Factur-X profiles are engine-supported but withheld
+ * (FNFE-MPE source gating, mirroring beliq-types SUPPORTED_FACTURX_PROFILE_IDS),
+ * and the standards outside LIVE_GENERATE_STANDARDS are absent entirely.
+ *
+ * `scripts/check-profile-drift.mjs` compares this against the engine's table.
+ */
+declare const LIVE_PROFILES_BY_STANDARD: {
+    readonly xrechnung: readonly ["xrechnung"];
+    readonly 'peppol-bis': readonly ["peppol", "romania-ro-cius", "netherlands-nlcius"];
+    readonly zugferd: readonly ["basicwl", "en16931", "extended"];
+    readonly facturx: readonly ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+};
+/** The profiles a caller may choose for `standard`; empty for an unknown standard. */
+declare function profilesForStandard(standard: string): readonly string[];
+/**
+ * Whether `profile` is legal for `standard`. An unknown standard passes: the API
+ * is the authority on values this list does not carry, and a client-side guess
+ * would refuse a request the server would have accepted.
+ */
+declare function isProfileAllowedForStandard(standard: string, profile: string): boolean;
+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, type GeneratePreset as G, LIVE_CONVERT_SOURCE_FORMATS as L, type PlainObject as P, type DocumentInput as a, LIVE_CONVERT_TARGET_FORMATS as b, LIVE_GENERATE_PRESETS as c, LIVE_GENERATE_STANDARDS as d, LIVE_PARSE_FORMATS as e, LIVE_PROFILES as f, LIVE_PROFILES_BY_STANDARD as g, LIVE_VALIDATE_FORMATS as h, compactQuery as i, decodeUtf8 as j, isPlainObject as k, isProfileAllowedForStandard as l, mergeDeep as m, DEFAULT_MAX_RETRIES as n, DEFAULT_TIMEOUT_MS as o, profilesForStandard as p, sniffContentType as s, toBytes as t };

package/dist/helpers.cjs

@@ -23,15 +23,19 @@ __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_PRESETS: () => LIVE_GENERATE_PRESETS,
   LIVE_GENERATE_STANDARDS: () => LIVE_GENERATE_STANDARDS,
   LIVE_PARSE_FORMATS: () => LIVE_PARSE_FORMATS,
   LIVE_PROFILES: () => LIVE_PROFILES,
+  LIVE_PROFILES_BY_STANDARD: () => LIVE_PROFILES_BY_STANDARD,
   LIVE_VALIDATE_FORMATS: () => LIVE_VALIDATE_FORMATS,
   buildRequest: () => buildRequest,
   compactQuery: () => compactQuery,
   decodeUtf8: () => decodeUtf8,
   isPlainObject: () => isPlainObject,
+  isProfileAllowedForStandard: () => isProfileAllowedForStandard,
   mergeDeep: () => mergeDeep,
+  profilesForStandard: () => profilesForStandard,
   sniffContentType: () => sniffContentType,
   toBytes: () => toBytes
 });
@@ -111,7 +115,8 @@ function buildRequest(params) {
         path: "/v1/generate",
         jsonBody: merged,
         contentType: "application/json",
-        outputKind: "binary"
+        // JSON mode returns the seal envelope; binary mode returns the raw document body.
+        ...params.sealed ? { accept: "application/json", outputKind: "json" } : { outputKind: "binary" }
       };
     }
     case "validate": {
@@ -161,7 +166,27 @@ function buildRequest(params) {
 // src/constants.ts
 var DEFAULT_BASE_URL = "https://api.beliq.eu";
 var LIVE_GENERATE_STANDARDS = ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+var LIVE_GENERATE_PRESETS = [
+  { id: "xrechnung", label: "XRechnung", standard: "xrechnung", output: "xml" },
+  { id: "factur-x", label: "Factur-X", standard: "facturx", output: "pdf", facturxProfile: "en16931" },
+  { id: "zugferd", label: "ZUGFeRD", standard: "zugferd", output: "pdf" },
+  { id: "peppol-bis", label: "Peppol BIS 3.0", standard: "peppol-bis", output: "xml" },
+  { id: "nlcius", label: "NLCIUS", standard: "peppol-bis", output: "xml", profile: "netherlands-nlcius" }
+];
 var LIVE_PROFILES = ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+var LIVE_PROFILES_BY_STANDARD = {
+  xrechnung: ["xrechnung"],
+  "peppol-bis": ["peppol", "romania-ro-cius", "netherlands-nlcius"],
+  zugferd: ["basicwl", "en16931", "extended"],
+  facturx: ["basicwl", "en16931", "extended", "extended-ctc-fr"]
+};
+function profilesForStandard(standard) {
+  return LIVE_PROFILES_BY_STANDARD[standard] ?? [];
+}
+function isProfileAllowedForStandard(standard, profile) {
+  const allowed = profilesForStandard(standard);
+  return allowed.length === 0 || allowed.includes(profile);
+}
 var LIVE_VALIDATE_FORMATS = ["auto", "cii", "ubl"];
 var LIVE_PARSE_FORMATS = ["auto", "cii", "ubl"];
 var LIVE_CONVERT_SOURCE_FORMATS = [
@@ -186,15 +211,19 @@ var LIVE_CONVERT_TARGET_FORMATS = [
   DEFAULT_BASE_URL,
   LIVE_CONVERT_SOURCE_FORMATS,
   LIVE_CONVERT_TARGET_FORMATS,
+  LIVE_GENERATE_PRESETS,
   LIVE_GENERATE_STANDARDS,
   LIVE_PARSE_FORMATS,
   LIVE_PROFILES,
+  LIVE_PROFILES_BY_STANDARD,
   LIVE_VALIDATE_FORMATS,
   buildRequest,
   compactQuery,
   decodeUtf8,
   isPlainObject,
+  isProfileAllowedForStandard,
   mergeDeep,
+  profilesForStandard,
   sniffContentType,
   toBytes
 });

package/dist/helpers.d.cts

@@ -1,5 +1,5 @@
-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';
+import { P as PlainObject } from './constants-BZuNzqbV.cjs';
+export { D as DEFAULT_BASE_URL, a as DocumentInput, G as GeneratePreset, L as LIVE_CONVERT_SOURCE_FORMATS, b as LIVE_CONVERT_TARGET_FORMATS, c as LIVE_GENERATE_PRESETS, d as LIVE_GENERATE_STANDARDS, e as LIVE_PARSE_FORMATS, f as LIVE_PROFILES, g as LIVE_PROFILES_BY_STANDARD, h as LIVE_VALIDATE_FORMATS, i as compactQuery, j as decodeUtf8, k as isPlainObject, l as isProfileAllowedForStandard, m as mergeDeep, p as profilesForStandard, s as sniffContentType, t as toBytes } from './constants-BZuNzqbV.cjs';
 
 type Operation = 'me' | 'generate' | 'validate' | 'parse' | 'convert';
 /** 'json' => parse the `{ success, data }` envelope; 'binary' => return raw bytes. */
@@ -15,6 +15,8 @@ interface BuildParams {
     verify?: boolean;
     template?: string;
     pdfTemplateId?: string;
+    /** Request the JSON-mode seal (Accept: application/json) instead of the binary body. */
+    sealed?: boolean;
     rawBody?: Uint8Array;
     rawContentType?: string;
     validateFormat?: string;
@@ -37,6 +39,8 @@ interface BuiltRequest {
     rawBody?: Uint8Array;
     /** Request content type; absent for GET. */
     contentType?: string;
+    /** Accept header; set when the caller wants a JSON envelope from an otherwise-binary op. */
+    accept?: string;
     outputKind: OutputKind;
 }
 declare function buildRequest(params: BuildParams): BuiltRequest;

package/dist/helpers.d.ts

@@ -1,5 +1,5 @@
-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';
+import { P as PlainObject } from './constants-BZuNzqbV.js';
+export { D as DEFAULT_BASE_URL, a as DocumentInput, G as GeneratePreset, L as LIVE_CONVERT_SOURCE_FORMATS, b as LIVE_CONVERT_TARGET_FORMATS, c as LIVE_GENERATE_PRESETS, d as LIVE_GENERATE_STANDARDS, e as LIVE_PARSE_FORMATS, f as LIVE_PROFILES, g as LIVE_PROFILES_BY_STANDARD, h as LIVE_VALIDATE_FORMATS, i as compactQuery, j as decodeUtf8, k as isPlainObject, l as isProfileAllowedForStandard, m as mergeDeep, p as profilesForStandard, s as sniffContentType, t as toBytes } from './constants-BZuNzqbV.js';
 
 type Operation = 'me' | 'generate' | 'validate' | 'parse' | 'convert';
 /** 'json' => parse the `{ success, data }` envelope; 'binary' => return raw bytes. */
@@ -15,6 +15,8 @@ interface BuildParams {
     verify?: boolean;
     template?: string;
     pdfTemplateId?: string;
+    /** Request the JSON-mode seal (Accept: application/json) instead of the binary body. */
+    sealed?: boolean;
     rawBody?: Uint8Array;
     rawContentType?: string;
     validateFormat?: string;
@@ -37,6 +39,8 @@ interface BuiltRequest {
     rawBody?: Uint8Array;
     /** Request content type; absent for GET. */
     contentType?: string;
+    /** Accept header; set when the caller wants a JSON envelope from an otherwise-binary op. */
+    accept?: string;
     outputKind: OutputKind;
 }
 declare function buildRequest(params: BuildParams): BuiltRequest;

package/dist/helpers.js

@@ -72,7 +72,8 @@ function buildRequest(params) {
         path: "/v1/generate",
         jsonBody: merged,
         contentType: "application/json",
-        outputKind: "binary"
+        // JSON mode returns the seal envelope; binary mode returns the raw document body.
+        ...params.sealed ? { accept: "application/json", outputKind: "json" } : { outputKind: "binary" }
       };
     }
     case "validate": {
@@ -122,7 +123,27 @@ function buildRequest(params) {
 // src/constants.ts
 var DEFAULT_BASE_URL = "https://api.beliq.eu";
 var LIVE_GENERATE_STANDARDS = ["xrechnung", "zugferd", "facturx", "peppol-bis"];
+var LIVE_GENERATE_PRESETS = [
+  { id: "xrechnung", label: "XRechnung", standard: "xrechnung", output: "xml" },
+  { id: "factur-x", label: "Factur-X", standard: "facturx", output: "pdf", facturxProfile: "en16931" },
+  { id: "zugferd", label: "ZUGFeRD", standard: "zugferd", output: "pdf" },
+  { id: "peppol-bis", label: "Peppol BIS 3.0", standard: "peppol-bis", output: "xml" },
+  { id: "nlcius", label: "NLCIUS", standard: "peppol-bis", output: "xml", profile: "netherlands-nlcius" }
+];
 var LIVE_PROFILES = ["basicwl", "en16931", "extended", "extended-ctc-fr"];
+var LIVE_PROFILES_BY_STANDARD = {
+  xrechnung: ["xrechnung"],
+  "peppol-bis": ["peppol", "romania-ro-cius", "netherlands-nlcius"],
+  zugferd: ["basicwl", "en16931", "extended"],
+  facturx: ["basicwl", "en16931", "extended", "extended-ctc-fr"]
+};
+function profilesForStandard(standard) {
+  return LIVE_PROFILES_BY_STANDARD[standard] ?? [];
+}
+function isProfileAllowedForStandard(standard, profile) {
+  const allowed = profilesForStandard(standard);
+  return allowed.length === 0 || allowed.includes(profile);
+}
 var LIVE_VALIDATE_FORMATS = ["auto", "cii", "ubl"];
 var LIVE_PARSE_FORMATS = ["auto", "cii", "ubl"];
 var LIVE_CONVERT_SOURCE_FORMATS = [
@@ -146,15 +167,19 @@ export {
   DEFAULT_BASE_URL,
   LIVE_CONVERT_SOURCE_FORMATS,
   LIVE_CONVERT_TARGET_FORMATS,
+  LIVE_GENERATE_PRESETS,
   LIVE_GENERATE_STANDARDS,
   LIVE_PARSE_FORMATS,
   LIVE_PROFILES,
+  LIVE_PROFILES_BY_STANDARD,
   LIVE_VALIDATE_FORMATS,
   buildRequest,
   compactQuery,
   decodeUtf8,
   isPlainObject,
+  isProfileAllowedForStandard,
   mergeDeep,
+  profilesForStandard,
   sniffContentType,
   toBytes
 };