@formfeed/engine 0.3.10 → 0.3.12

package/types/lib/design/parse.d.cts

@@ -0,0 +1,25 @@
+import { type DesignDocument } from './types.cjs';
+/**
+ * Reads a design as it arrives from `settings.design`: from the editor, but also from the API or a
+ * pushed `design.json`, so nothing is trusted. Every value is checked, numbers are clamped to sane
+ * ranges, and a problem names where it is; a design with problems is not half loaded (the editor opens
+ * the template as code and says so).
+ */
+export declare const DESIGN_LIMITS: {
+    readonly layers: 200;
+    readonly textPerLayer: 5000;
+    readonly bytes: number;
+};
+export type ParsedDesign = {
+    design: DesignDocument;
+    problems: [];
+} | {
+    design: null;
+    problems: string[];
+};
+export declare const layerIdPattern: RegExp;
+/** A data path the emitter writes as is in every engine: dotted identifiers. */
+export declare const dataPathPattern: RegExp;
+/** A design's size as the gateway bounds it: the UTF-8 bytes of its JSON. */
+export declare function designBytes(value: unknown): number;
+export declare function parseDesign(value: unknown): ParsedDesign;

package/types/lib/design/parse.d.ts

@@ -0,0 +1,25 @@
+import { type DesignDocument } from './types.js';
+/**
+ * Reads a design as it arrives from `settings.design`: from the editor, but also from the API or a
+ * pushed `design.json`, so nothing is trusted. Every value is checked, numbers are clamped to sane
+ * ranges, and a problem names where it is; a design with problems is not half loaded (the editor opens
+ * the template as code and says so).
+ */
+export declare const DESIGN_LIMITS: {
+    readonly layers: 200;
+    readonly textPerLayer: 5000;
+    readonly bytes: number;
+};
+export type ParsedDesign = {
+    design: DesignDocument;
+    problems: [];
+} | {
+    design: null;
+    problems: string[];
+};
+export declare const layerIdPattern: RegExp;
+/** A data path the emitter writes as is in every engine: dotted identifiers. */
+export declare const dataPathPattern: RegExp;
+/** A design's size as the gateway bounds it: the UTF-8 bytes of its JSON. */
+export declare function designBytes(value: unknown): number;
+export declare function parseDesign(value: unknown): ParsedDesign;

package/types/lib/design/starters.d.cts

@@ -0,0 +1,14 @@
+import { type CanvasSize, type DesignDocument } from './types.cjs';
+/**
+ * Designs a new image template can start from (plan 16 §4.2). Titles stay English here; the app words
+ * them per locale by `id`. Sample data uses the placeholders of CLAUDE.md, never names that could be
+ * real.
+ */
+export interface DesignStarter {
+    id: 'blank' | 'article' | 'quote' | 'event';
+    title: string;
+    size: CanvasSize;
+    design: DesignDocument;
+    sampleData: Record<string, unknown>;
+}
+export declare const designStarters: DesignStarter[];

package/types/lib/design/starters.d.ts

@@ -0,0 +1,14 @@
+import { type CanvasSize, type DesignDocument } from './types.js';
+/**
+ * Designs a new image template can start from (plan 16 §4.2). Titles stay English here; the app words
+ * them per locale by `id`. Sample data uses the placeholders of CLAUDE.md, never names that could be
+ * real.
+ */
+export interface DesignStarter {
+    id: 'blank' | 'article' | 'quote' | 'event';
+    title: string;
+    size: CanvasSize;
+    design: DesignDocument;
+    sampleData: Record<string, unknown>;
+}
+export declare const designStarters: DesignStarter[];

package/types/lib/design/types.d.cts

@@ -0,0 +1,171 @@
+/**
+ * A visual design (plan 16 §4.1): the layer model the editor's canvas edits, stored as
+ * `settings.design` and turned into the template's body and CSS by `emitDesign`. Renders never read
+ * it; the emitted HTML is the template. Coordinates are CSS pixels of the image, whose size stays in
+ * `settings.image`.
+ */
+export declare const DESIGN_VERSION = 1;
+/** A colour: a literal, or a brand kit colour by name with the literal it falls back to. */
+export type Paint = {
+    color: string;
+} | {
+    brand: string;
+    fallback: string;
+};
+export interface Shadow {
+    x: number;
+    y: number;
+    blur: number;
+    color: string;
+}
+export interface Stroke {
+    width: number;
+    paint: Paint;
+}
+/** A font: a family by source, or one of the brand kit's two. */
+export type FontChoice = {
+    family: string;
+    source: 'google' | 'organisation' | 'system';
+} | {
+    brand: 'heading' | 'body';
+};
+/** How a data value is shown: through one of the helpers every engine has. */
+export type TextFormat = {
+    helper: 'upper' | 'lower' | 'title' | 'money';
+} | {
+    helper: 'number';
+    decimals: number;
+} | {
+    helper: 'date';
+    pattern: string;
+} | {
+    helper: 'truncate';
+    length: number;
+} | {
+    helper: 'default';
+    value: string;
+};
+/** Text of a text layer: literal text, a data path (a chip in the editor), a line break. */
+export type TextItem = {
+    text: string;
+} | {
+    path: string;
+    format?: TextFormat;
+} | {
+    break: true;
+};
+export interface TextStyle {
+    font: FontChoice;
+    weight: number;
+    size: number;
+    lineHeight: number;
+    letterSpacing: number;
+    color: Paint;
+    align: 'left' | 'center' | 'right' | 'justify';
+    italic?: boolean;
+    uppercase?: boolean;
+    underline?: boolean;
+    /** A line through the text; with `underline` both lines are drawn. */
+    strike?: boolean;
+}
+/** Where an image comes from; an empty `url`, `asset` or `path` is one not chosen yet (`imageIsEmpty`). */
+export type ImageSource = {
+    url: string;
+} | {
+    asset: string;
+} | {
+    path: string;
+} | {
+    brandLogo: 'primary' | 'inverse' | 'mark';
+};
+/** What a code encodes: literal text or a data path. */
+export type Binding = {
+    text: string;
+} | {
+    path: string;
+};
+export type BarcodeSymbology = 'code128' | 'ean13' | 'ean8' | 'upca' | 'itf14' | 'code39';
+export interface LayerBase {
+    /** Stable, `[a-z][a-z0-9-]{0,31}`: the class `l-<id>` and `data-ff-layer`. Never renamed. */
+    id: string;
+    /** What the layers panel shows. */
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Degrees, clockwise like CSS. */
+    rotation: number;
+    opacity: number;
+    /** False: the layer is not emitted at all. */
+    visible: boolean;
+    /** Editor only. */
+    locked?: boolean;
+    /** Emitted inside an if block: shown only when the data path has a value. */
+    showWhen?: {
+        path: string;
+    } | null;
+    radius?: number;
+    shadow?: Shadow | null;
+    stroke?: Stroke | null;
+}
+export interface TextLayer extends LayerBase {
+    type: 'text';
+    content: TextItem[];
+    style: TextStyle;
+    /** `fixed` clips, `shrink` makes the text smaller until it fits (`data-ff-fit`), `grow` lets the box grow. */
+    sizing: 'fixed' | 'shrink' | 'grow';
+    minFontSize?: number;
+    maxLines?: number;
+    valign: 'top' | 'middle' | 'bottom';
+    fill?: Paint | null;
+    padding?: number;
+}
+export interface ImageLayer extends LayerBase {
+    type: 'image';
+    source: ImageSource;
+    fit: 'cover' | 'contain' | 'fill';
+    /** Which point stays in view when `cover` crops, in percent. */
+    focus?: {
+        x: number;
+        y: number;
+    };
+}
+export interface ShapeLayer extends LayerBase {
+    type: 'shape';
+    shape: 'rectangle' | 'ellipse' | 'line';
+    fill: Paint | null;
+}
+export interface QrLayer extends LayerBase {
+    type: 'qr';
+    value: Binding;
+    ecc: 'L' | 'M' | 'Q' | 'H';
+    color: Paint;
+    background: Paint | null;
+}
+export interface BarcodeLayer extends LayerBase {
+    type: 'barcode';
+    value: Binding;
+    symbology: BarcodeSymbology;
+    showText: boolean;
+}
+export type DesignLayer = TextLayer | ImageLayer | ShapeLayer | QrLayer | BarcodeLayer;
+export type LayerType = DesignLayer['type'];
+export interface DesignDocument {
+    version: typeof DESIGN_VERSION;
+    /** Hash of the body and CSS the emitter last wrote (`designOutputHash`); other code means it was edited. */
+    output: string;
+    /** The canvas colour; null is transparent, which only shows when `settings.image.transparent` is set. */
+    background: Paint | null;
+    /** Bottom to top: the stacking order is the order in the HTML. */
+    layers: DesignLayer[];
+    guides?: {
+        x: number[];
+        y: number[];
+    };
+}
+/** The image a design is drawn on, from `settings.image`. */
+export interface CanvasSize {
+    width: number;
+    height: number;
+}

package/types/lib/design/types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * A visual design (plan 16 §4.1): the layer model the editor's canvas edits, stored as
+ * `settings.design` and turned into the template's body and CSS by `emitDesign`. Renders never read
+ * it; the emitted HTML is the template. Coordinates are CSS pixels of the image, whose size stays in
+ * `settings.image`.
+ */
+export declare const DESIGN_VERSION = 1;
+/** A colour: a literal, or a brand kit colour by name with the literal it falls back to. */
+export type Paint = {
+    color: string;
+} | {
+    brand: string;
+    fallback: string;
+};
+export interface Shadow {
+    x: number;
+    y: number;
+    blur: number;
+    color: string;
+}
+export interface Stroke {
+    width: number;
+    paint: Paint;
+}
+/** A font: a family by source, or one of the brand kit's two. */
+export type FontChoice = {
+    family: string;
+    source: 'google' | 'organisation' | 'system';
+} | {
+    brand: 'heading' | 'body';
+};
+/** How a data value is shown: through one of the helpers every engine has. */
+export type TextFormat = {
+    helper: 'upper' | 'lower' | 'title' | 'money';
+} | {
+    helper: 'number';
+    decimals: number;
+} | {
+    helper: 'date';
+    pattern: string;
+} | {
+    helper: 'truncate';
+    length: number;
+} | {
+    helper: 'default';
+    value: string;
+};
+/** Text of a text layer: literal text, a data path (a chip in the editor), a line break. */
+export type TextItem = {
+    text: string;
+} | {
+    path: string;
+    format?: TextFormat;
+} | {
+    break: true;
+};
+export interface TextStyle {
+    font: FontChoice;
+    weight: number;
+    size: number;
+    lineHeight: number;
+    letterSpacing: number;
+    color: Paint;
+    align: 'left' | 'center' | 'right' | 'justify';
+    italic?: boolean;
+    uppercase?: boolean;
+    underline?: boolean;
+    /** A line through the text; with `underline` both lines are drawn. */
+    strike?: boolean;
+}
+/** Where an image comes from; an empty `url`, `asset` or `path` is one not chosen yet (`imageIsEmpty`). */
+export type ImageSource = {
+    url: string;
+} | {
+    asset: string;
+} | {
+    path: string;
+} | {
+    brandLogo: 'primary' | 'inverse' | 'mark';
+};
+/** What a code encodes: literal text or a data path. */
+export type Binding = {
+    text: string;
+} | {
+    path: string;
+};
+export type BarcodeSymbology = 'code128' | 'ean13' | 'ean8' | 'upca' | 'itf14' | 'code39';
+export interface LayerBase {
+    /** Stable, `[a-z][a-z0-9-]{0,31}`: the class `l-<id>` and `data-ff-layer`. Never renamed. */
+    id: string;
+    /** What the layers panel shows. */
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Degrees, clockwise like CSS. */
+    rotation: number;
+    opacity: number;
+    /** False: the layer is not emitted at all. */
+    visible: boolean;
+    /** Editor only. */
+    locked?: boolean;
+    /** Emitted inside an if block: shown only when the data path has a value. */
+    showWhen?: {
+        path: string;
+    } | null;
+    radius?: number;
+    shadow?: Shadow | null;
+    stroke?: Stroke | null;
+}
+export interface TextLayer extends LayerBase {
+    type: 'text';
+    content: TextItem[];
+    style: TextStyle;
+    /** `fixed` clips, `shrink` makes the text smaller until it fits (`data-ff-fit`), `grow` lets the box grow. */
+    sizing: 'fixed' | 'shrink' | 'grow';
+    minFontSize?: number;
+    maxLines?: number;
+    valign: 'top' | 'middle' | 'bottom';
+    fill?: Paint | null;
+    padding?: number;
+}
+export interface ImageLayer extends LayerBase {
+    type: 'image';
+    source: ImageSource;
+    fit: 'cover' | 'contain' | 'fill';
+    /** Which point stays in view when `cover` crops, in percent. */
+    focus?: {
+        x: number;
+        y: number;
+    };
+}
+export interface ShapeLayer extends LayerBase {
+    type: 'shape';
+    shape: 'rectangle' | 'ellipse' | 'line';
+    fill: Paint | null;
+}
+export interface QrLayer extends LayerBase {
+    type: 'qr';
+    value: Binding;
+    ecc: 'L' | 'M' | 'Q' | 'H';
+    color: Paint;
+    background: Paint | null;
+}
+export interface BarcodeLayer extends LayerBase {
+    type: 'barcode';
+    value: Binding;
+    symbology: BarcodeSymbology;
+    showText: boolean;
+}
+export type DesignLayer = TextLayer | ImageLayer | ShapeLayer | QrLayer | BarcodeLayer;
+export type LayerType = DesignLayer['type'];
+export interface DesignDocument {
+    version: typeof DESIGN_VERSION;
+    /** Hash of the body and CSS the emitter last wrote (`designOutputHash`); other code means it was edited. */
+    output: string;
+    /** The canvas colour; null is transparent, which only shows when `settings.image.transparent` is set. */
+    background: Paint | null;
+    /** Bottom to top: the stacking order is the order in the HTML. */
+    layers: DesignLayer[];
+    guides?: {
+        x: number[];
+        y: number[];
+    };
+}
+/** The image a design is drawn on, from `settings.image`. */
+export interface CanvasSize {
+    width: number;
+    height: number;
+}

package/types/lib/dialect.d.cts

@@ -0,0 +1,32 @@
+import type { EngineId } from './types.cjs';
+/**
+ * Template syntax per engine, for code that writes templates: the snippet library (spec 06 §2) and
+ * the design emitter (plan 16 §4.2). Jinja2 passes filter arguments in parentheses, Liquid after a
+ * colon (and cannot build object literals, so options are keyword arguments), Handlebars calls
+ * helpers with positional arguments and a hash.
+ */
+/** Handlebars has no loop variable: inside `{{#each}}` the item's fields are read directly. */
+export declare const loop: (engine: EngineId, item: string, list: string, body: string) => string;
+/** An expression, optionally through one filter written the Jinja2 way (`date('dd.MM.yyyy')`). */
+export declare const val: (engine: EngineId, expr: string, filter?: string) => string;
+export declare const ifElse: (engine: EngineId, cond: string, then: string, otherwise: string) => string;
+/** A `t` call with optional placeholder params (`{ rate: 'invoice.vat_rate' }`, values are expressions). */
+export declare const tr: (engine: EngineId, key: string, params?: Record<string, string>) => string;
+/** `body` only when `cond` has a value. */
+export declare const ifBlock: (engine: EngineId, cond: string, body: string) => string;
+/**
+ * A string literal the engine reads back as `value`. Liquid has no escapes, so it takes whichever
+ * quote the value lacks and turns an apostrophe into a typographic one when it contains both.
+ */
+export declare function stringLiteral(engine: EngineId, value: string): string;
+/**
+ * `input` through a filter with literal-or-expression arguments, as one output tag: Jinja2
+ * `{{ x | f(a, b) }}`, Liquid `{{ x | f: a, b }}`, Handlebars `{{f x a b}}`.
+ */
+export declare function filterCall(engine: EngineId, input: string, name: string, args?: string[]): string;
+/**
+ * A helper that takes an input and named options, as one output tag: Jinja2
+ * `{{ f(x, { a: 1 }) }}`, Liquid `{{ x | f: a: 1 }}`, Handlebars `{{f x a=1}}`. Option values are
+ * expressions or literals the caller wrote with `stringLiteral`.
+ */
+export declare function helperCall(engine: EngineId, name: string, input: string, options?: Record<string, string>): string;

package/types/lib/dialect.d.ts

@@ -0,0 +1,32 @@
+import type { EngineId } from './types.js';
+/**
+ * Template syntax per engine, for code that writes templates: the snippet library (spec 06 §2) and
+ * the design emitter (plan 16 §4.2). Jinja2 passes filter arguments in parentheses, Liquid after a
+ * colon (and cannot build object literals, so options are keyword arguments), Handlebars calls
+ * helpers with positional arguments and a hash.
+ */
+/** Handlebars has no loop variable: inside `{{#each}}` the item's fields are read directly. */
+export declare const loop: (engine: EngineId, item: string, list: string, body: string) => string;
+/** An expression, optionally through one filter written the Jinja2 way (`date('dd.MM.yyyy')`). */
+export declare const val: (engine: EngineId, expr: string, filter?: string) => string;
+export declare const ifElse: (engine: EngineId, cond: string, then: string, otherwise: string) => string;
+/** A `t` call with optional placeholder params (`{ rate: 'invoice.vat_rate' }`, values are expressions). */
+export declare const tr: (engine: EngineId, key: string, params?: Record<string, string>) => string;
+/** `body` only when `cond` has a value. */
+export declare const ifBlock: (engine: EngineId, cond: string, body: string) => string;
+/**
+ * A string literal the engine reads back as `value`. Liquid has no escapes, so it takes whichever
+ * quote the value lacks and turns an apostrophe into a typographic one when it contains both.
+ */
+export declare function stringLiteral(engine: EngineId, value: string): string;
+/**
+ * `input` through a filter with literal-or-expression arguments, as one output tag: Jinja2
+ * `{{ x | f(a, b) }}`, Liquid `{{ x | f: a, b }}`, Handlebars `{{f x a b}}`.
+ */
+export declare function filterCall(engine: EngineId, input: string, name: string, args?: string[]): string;
+/**
+ * A helper that takes an input and named options, as one output tag: Jinja2
+ * `{{ f(x, { a: 1 }) }}`, Liquid `{{ x | f: a: 1 }}`, Handlebars `{{f x a=1}}`. Option values are
+ * expressions or literals the caller wrote with `stringLiteral`.
+ */
+export declare function helperCall(engine: EngineId, name: string, input: string, options?: Record<string, string>): string;

package/types/lib/einvoice/check.d.cts

@@ -0,0 +1,181 @@
+import { type EinvoiceProfile, type VatCategory } from './schema.cjs';
+/**
+ * Reads an `_invoice` block against EN 16931 (spec 17 §4.3): the shape first, then the rules a
+ * request can be held to before anything is rendered. What comes out is either the invoice with
+ * every number as exact decimal text, ready for the XML, or the list of what is wrong, each finding
+ * with the field and the rule it breaks.
+ *
+ * Nothing is computed for the caller and nothing is rounded into place. A total that is a cent off
+ * is a finding, because an e-invoice whose XML disagrees with the seller's books is a tax problem,
+ * and correcting it here would hide exactly that.
+ *
+ * The full rule set (the official schematron, some 430 assertions) runs in the sidecar on every
+ * document. This is the part worth knowing early: it needs no JVM, so the gateway answers a bad
+ * request at once, and the editor and the CLI say the same thing offline.
+ */
+export interface InvoiceProblem {
+    /** What kind of finding, for a caller that words it in its own language. */
+    code: InvoiceProblemCode;
+    /** The field inside `_invoice`, dotted, list items as `lines[1]` (zero-based). */
+    path: string;
+    /** The rule of EN 16931 (`BR-CO-15`) or of the French specifications (`BR-FR-10`), where one applies. */
+    rule?: string;
+    /** The same in English, naming the field and the rule. */
+    message: string;
+    /** The values `message` was built from. */
+    args: Record<string, string | number>;
+}
+export type InvoiceProblemCode = 'missing' | 'invalid' | 'not_a_number' | 'decimals' | 'negative' | 'code_list' | 'date' | 'date_order' | 'scheme_required' | 'vat_id_prefix' | 'iban' | 'sum' | 'breakdown_missing' | 'breakdown_duplicate' | 'rate_required' | 'rate_positive' | 'rate_zero' | 'rate_forbidden' | 'amount_zero' | 'exemption_reason_required' | 'exemption_reason_forbidden' | 'seller_tax_id_required' | 'buyer_tax_id_required' | 'vat_id_forbidden' | 'only_category' | 'delivery_required' | 'account_required' | 'means_code_required' | 'due_or_terms_required' | 'seller_identifier_required' | 'siren_mismatch' | 'fr_seller_siren' | 'fr_buyer_siren' | 'fr_operation' | 'fr_vat_on_debits' | 'profile';
+export interface Identifier {
+    value: string;
+    scheme?: string;
+}
+export interface InvoiceAddress {
+    street?: string;
+    street2?: string;
+    street3?: string;
+    postcode?: string;
+    city?: string;
+    country: string;
+    subdivision?: string;
+}
+export interface InvoiceParty {
+    name: string;
+    trading_name?: string;
+    id?: Identifier;
+    legal_registration?: Identifier;
+    vat_id?: string;
+    address: InvoiceAddress;
+    contact?: {
+        name?: string;
+        phone?: string;
+        email?: string;
+    };
+    electronic_address?: Required<Identifier>;
+}
+export interface InvoiceAllowance {
+    amount: string;
+    reason?: string;
+    reason_code?: string;
+    base_amount?: string;
+    percent?: string;
+}
+export interface InvoiceTax {
+    category: VatCategory;
+    /** Percent as decimal text; absent for category O only. */
+    rate?: string;
+}
+export interface InvoiceLine {
+    id: string;
+    name: string;
+    description?: string;
+    quantity: string;
+    unit_code: string;
+    net_price: string;
+    price_base_quantity?: string;
+    net_amount: string;
+    tax: InvoiceTax;
+    period?: {
+        start?: string;
+        end?: string;
+    };
+    allowances: InvoiceAllowance[];
+    charges: InvoiceAllowance[];
+    buyer_accounting_reference?: string;
+    note?: string;
+    seller_item_id?: string;
+    buyer_item_id?: string;
+    standard_item_id?: Identifier;
+    order_line_reference?: string;
+}
+export interface InvoiceBreakdown extends InvoiceTax {
+    basis: string;
+    amount: string;
+    exemption_reason?: string;
+    exemption_reason_code?: string;
+}
+/**
+ * An invoice that passed: every amount is decimal text with at most two places, every code is in
+ * its list, and the totals add up. The XML is written from this and from nothing else.
+ */
+export interface Invoice {
+    number: string;
+    issue_date: string;
+    type_code: string;
+    currency: string;
+    accounting_currency?: string;
+    buyer_reference?: string;
+    order_reference?: string;
+    contract_reference?: string;
+    notes: Array<{
+        text: string;
+        subject_code?: string;
+    }>;
+    period?: {
+        start?: string;
+        end?: string;
+    };
+    preceding_invoices: Array<{
+        number: string;
+        issue_date?: string;
+    }>;
+    /** The business process (BT-23); French invoices carry their billing framework here. */
+    business_process?: string;
+    seller: InvoiceParty & {
+        tax_number?: string;
+        legal_info?: string;
+        vat_on_debits?: boolean;
+    };
+    buyer: InvoiceParty;
+    delivery?: {
+        name?: string;
+        date?: string;
+        address?: InvoiceAddress;
+    };
+    lines: InvoiceLine[];
+    allowances: Array<InvoiceAllowance & {
+        tax: InvoiceTax;
+    }>;
+    charges: Array<InvoiceAllowance & {
+        tax: InvoiceTax;
+    }>;
+    breakdown: InvoiceBreakdown[];
+    totals: {
+        line_net: string;
+        allowances?: string;
+        charges?: string;
+        tax_basis: string;
+        tax_total: string;
+        tax_total_accounting?: string;
+        grand: string;
+        prepaid?: string;
+        rounding?: string;
+        due: string;
+    };
+    payment?: {
+        means_code?: string;
+        iban?: string;
+        bic?: string;
+        account_name?: string;
+        reference?: string;
+        terms?: string;
+        due_date?: string;
+        mandate_id?: string;
+        creditor_id?: string;
+        debited_iban?: string;
+    };
+}
+export type InvoiceCheck = {
+    ok: true;
+    invoice: Invoice;
+    problems: [];
+} | {
+    ok: false;
+    invoice: null;
+    problems: InvoiceProblem[];
+};
+export interface CheckOptions {
+    /** The profile the XML will be written in; `basic` cannot carry everything `en16931` can. */
+    profile?: EinvoiceProfile;
+}
+export declare function checkInvoice(data: unknown, options?: CheckOptions): InvoiceCheck;