@xml-auditfile/auditfile 0.0.0-stage → 0.0.2-alpha.1

package/types/reading/mapping-plan.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The paths of an import as a tree, built once per import: every node knows its table, column or group.
+ * Reading an element is then one lookup of its local name under the current node, instead of building the
+ * full path as a string and looking that up. Only known paths have a node, so a file cannot make the tree grow.
+ */
+export declare class MappingPlan {
+    #private;
+    /** Above the root element: its only child is the root element of the version. */
+    root: PathNode;
+    /** @param {import('../schema/schema.js').AuditfileSchema} schema */
+    constructor(schema: import('../schema/schema.js').AuditfileSchema);
+}
+/** A known element or attribute path. */
+export declare class PathNode {
+    path: string;
+    /** @type {TablePlan | null} */
+    table: TablePlan | null;
+    /** @type {{ table: TablePlan, column: import('../schema/schema.js').SchemaColumn } | null} */
+    column: {
+        table: TablePlan;
+        column: import('../schema/schema.js').SchemaColumn;
+    } | null;
+    /** A flattened element or pure container: no table and no column. */
+    isGroup: boolean;
+    /** @type {Map<string, PathNode>} Child elements by local name. */
+    children: Map<string, PathNode>;
+    /** @type {Map<string, PathNode>} Attributes by local name. */
+    attributes: Map<string, PathNode>;
+    /** @param {string} path The full path, e.g. "auditfile/company/transactions"; attributes as ".../@name". */
+    constructor(path: string);
+    /** The path of an unknown child, for a diagnostic. */
+    childPath(localName: any): any;
+}
+export declare class TablePlan {
+    table: import("../schema/schema.js").SchemaTable;
+    /** A repeating simple element: one "value" column read from the element text. */
+    isValueTable: boolean;
+    /** @type {{ column: import('../schema/schema.js').SchemaColumn, group: PathNode | null }[]} Columns with minOccurs ≥ 1, with the group they are in. */
+    required: {
+        column: import('../schema/schema.js').SchemaColumn;
+        group: PathNode | null;
+    }[];
+    /** @param {import('../schema/schema.js').SchemaTable} table */
+    constructor(table: import('../schema/schema.js').SchemaTable);
+}

package/types/reading/read-options.d.ts

@@ -0,0 +1,69 @@
+import { AuditfileVersion } from '../versioning/version.js';
+/** How the reader treats the file. */
+export declare const ReadMode: Readonly<{
+    /** Validate against the XSD first; load only a valid file. */
+    Verified: "verified";
+    /** Load directly with the manifest; elements outside the manifest are reported and skipped. */
+    Unverified: "unverified";
+}>;
+/** Progress of a read. */
+export declare class ReadProgress {
+    /** Rows read so far. */
+    rowsRead: any;
+    /** Total rows, when known from the scan phase; otherwise null. */
+    totalRows: any;
+}
+export type ReadOptions = {
+    /**
+     * Force a version, e.g. `AuditfileVersion.Financial.V3_2` or "xaf/3.2". Null: determine from the namespace.
+     */
+    version?: AuditfileVersion | string | null;
+    /**
+     * Verified (default) or unverified.
+     */
+    mode?: 'verified' | 'unverified';
+    /**
+     * Derive the version from an unknown namespace, e.g. ".../XAF/3.2/". Off by default.
+     */
+    useResolver?: boolean;
+    /**
+     * Own XSD instead of the built-in one, as a factory of bytes or a stream. Null: use the built-in XSD.
+     */
+    xsd?: (() => unknown) | null;
+    /**
+     * Apply known dialect corrections. On by default.
+     */
+    applyDialects?: boolean;
+    /**
+     * Rows per table handed to the sink at once (default 1000).
+     */
+    batchSize?: number;
+    /**
+     * Language of diagnostic messages (default Dutch).
+     */
+    language?: 'nl' | 'en';
+    /**
+     * Maximum number of diagnostics; the rest is summarized (default 1000).
+     */
+    maxDiagnostics?: number;
+    /**
+     * Maximum element nesting; deeper files are refused (default 64).
+     */
+    maxDepth?: number;
+    /**
+     * Maximum characters in the whole document, all parts together; a larger file stops with XAF-X001 (default 4 Gi; 0 is no limit).
+     */
+    maxCharactersInDocument?: number;
+    /**
+     * Maximum characters of one value; a longer value is skipped with XAF-S008 and never held in memory as a whole (default 65536; the longest value an XSD allows is 999).
+     */
+    maxValueLength?: number;
+    /**
+     * Receives progress after every batch.
+     */
+    onProgress?: ((progress: ReadProgress) => void) | null;
+    /**
+     * Cancels reading, in the scan phase as well as the load phase; the call then rejects with the signal's reason.
+     */
+    signal?: AbortSignal | null;
+};

package/types/reading/read-session.d.ts

@@ -0,0 +1,28 @@
+import { DiagnosticCollector } from '../diagnostics/collector.js';
+import { AuditfileReport } from '../diagnostics/report.js';
+import { AuditfileSchema } from '../schema/schema.js';
+/**
+ * One read of one source: resolve the version, optionally scan (validate and count),
+ * then load (stream rows). Holds the diagnostics and the part statistics.
+ */
+export declare class ReadSession {
+    #private;
+    diagnostics: DiagnosticCollector;
+    /** @type {import('../versioning/version-resolver.js').Resolution | null} */
+    resolution: import('../versioning/version-resolver.js').Resolution | null;
+    /** @type {AuditfileSchema | null} */
+    schema: AuditfileSchema | null;
+    /** True when the load phase must validate against the XSD itself (single-use source). */
+    validateDuringLoad: boolean;
+    constructor(source: any, options: any);
+    get parts(): any;
+    /** Resolves the version and runs the scan phase when useful. Returns false when loading must not start. */
+    prepare(sinkNeedsRowCounts: any, scanOnly?: boolean): Promise<boolean>;
+    /** The load phase as a stream of rows. Diagnostics are collected along the way. Can be iterated once. */
+    load(): AsyncGenerator<import("./row.js").AuditfileRow, void, unknown>;
+    /** True when the load phase has read the whole file. */
+    get loaded(): boolean;
+    createReport(loaded: any): AuditfileReport;
+    /** Releases a document kept for loading that will not be loaded after all. */
+    dispose(): Promise<void>;
+}

package/types/reading/row-loader.d.ts

@@ -0,0 +1,18 @@
+import { AuditfileRow } from './row.js';
+/**
+ * The load phase: walks the XML once and turns elements into rows using the mapping plan.
+ * A row is emitted when its element closes, so all its columns are known; ids are assigned when it opens,
+ * so they follow document order. Only the open elements are kept in memory.
+ */
+export declare class RowLoader {
+    #private;
+    /** True when reading stopped on a fatal error. */
+    stopped: boolean;
+    /**
+     * @param {import('../internal/xml-reader.js').XmlReader} reader
+     * @param {((event: object) => void) | null} validate Feeds the XSD validator, when validating during load.
+     */
+    constructor(reader: import('../internal/xml-reader.js').XmlReader, schema: any, resolution: any, options: any, diagnostics: any, observers: any, validate: ((event: object) => void) | null);
+    /** @returns {AsyncGenerator<AuditfileRow>} Rows in document order of their closing tags. */
+    rows(): AsyncGenerator<AuditfileRow>;
+}

package/types/reading/row.d.ts

@@ -0,0 +1,53 @@
+import { Decimal } from '../internal/decimal.js';
+/**
+ * One row of a table. {@link AuditfileRow#values} follows the column order of {@link AuditfileRow#table};
+ * the JavaScript type of a value follows the column type (string, Decimal, number, Date, string "HH:MM:SS", boolean) or is null.
+ *
+ * Prefer the typed accessors ({@link AuditfileRow#getDecimal}, {@link AuditfileRow#getString}, ...) over {@link AuditfileRow#get}:
+ * they check the column type and say what is wrong. Every accessor takes a column name or a `SchemaColumn`; in a loop over
+ * many rows, look the column up once with `table.findColumn()` and pass it.
+ */
+export declare class AuditfileRow {
+    #private;
+    /** @type {import('../schema/schema.js').SchemaTable} The table this row belongs to. */
+    table: import('../schema/schema.js').SchemaTable;
+    /** Unique within the import; assigned in document order. */
+    id: any;
+    /** Id of the parent row, or null for the root. */
+    parentId: any;
+    /** Position under the parent row (1-based), per table. */
+    ordinal: any;
+    /** Source part the row came from (1-based). */
+    part: any;
+    /** @type {readonly unknown[]} Column values in column order. */
+    values: readonly unknown[];
+    /**
+     * Value of a column.
+     * @param {string | import('../schema/schema.js').SchemaColumn} column
+     * @throws {RangeError} The column does not exist in this table.
+     */
+    get(column: string | import('../schema/schema.js').SchemaColumn): unknown;
+    /**
+     * True when this table has the column (a column may exist in one version and not in another).
+     * @param {string} column
+     */
+    has(column: string): boolean;
+    /** @returns {string | null} A string column. @throws {RangeError | TypeError} */
+    getString(column: any): string | null;
+    /**
+     * A decimal column, or an integer column as a Decimal (a column can be integer in one version and decimal in another).
+     * @returns {Decimal | null}
+     * @throws {RangeError | TypeError}
+     */
+    getDecimal(column: any): Decimal | null;
+    /** @returns {number | null} An integer column. @throws {RangeError | TypeError} */
+    getInteger(column: any): number | null;
+    /** @returns {Date | null} A date column (midnight UTC). @throws {RangeError | TypeError} */
+    getDate(column: any): Date | null;
+    /** @returns {Date | null} A date-time column, or a date column at midnight UTC. @throws {RangeError | TypeError} */
+    getDateTime(column: any): Date | null;
+    /** @returns {string | null} A time column, "HH:MM:SS". @throws {RangeError | TypeError} */
+    getTime(column: any): string | null;
+    /** @returns {boolean | null} A boolean column. @throws {RangeError | TypeError} */
+    getBoolean(column: any): boolean | null;
+}

package/types/reading/source.d.ts

@@ -0,0 +1,73 @@
+/** Opens a part; internal so callers cannot bypass the single-use check. */
+export declare const OPEN: unique symbol;
+/** A source used in a way it does not allow, such as reading a single-use stream twice: the caller's mistake. */
+export declare class SourceUsageError extends Error {
+    constructor(message: any);
+}
+/**
+ * Where an audit file comes from: one stream, or several streams for the parts of a split audit file.
+ * The reader never opens files itself; the caller supplies the streams, so the same code runs on a server and in the browser.
+ * A factory can be read twice (scan, then load); a plain stream only once.
+ *
+ * A stream is a Node Readable, a web ReadableStream, a Blob, a Uint8Array, an ArrayBuffer,
+ * or any (async) iterable of Uint8Array chunks.
+ */
+export declare class AuditfileSource {
+    /** @type {readonly SourcePart[]} The parts in reading order. */
+    parts: readonly SourcePart[];
+    /** @param {SourcePart[]} parts */
+    constructor(parts: SourcePart[]);
+    /** True when every part can be opened again, so the reader can scan before loading. */
+    get canReadTwice(): boolean;
+    /**
+     * A stream that can be read only once. The reader does not close or destroy it.
+     * @param {unknown} stream
+     * @param {string} [name]
+     */
+    static fromStream(stream: unknown, name?: string): AuditfileSource;
+    /**
+     * A split audit file as streams that can be read only once: the first part followed by its continuation parts, in order.
+     * The reader does not close or destroy the streams.
+     * @param {...[string, unknown]} parts
+     */
+    static fromStreams(...parts: [string, unknown][]): AuditfileSource;
+    /**
+     * A stream factory that returns a fresh stream (or a promise of one) on every call, so the source can be read twice.
+     * The reader closes the streams it gets.
+     * @example
+     * AuditfileSource.fromFactory(() => fs.createReadStream('admin.xaf'), 'admin.xaf');
+     * AuditfileSource.fromFactory(() => bytes);
+     * @param {() => unknown} open
+     * @param {string} [name]
+     */
+    static fromFactory(open: () => unknown, name?: string): AuditfileSource;
+    /**
+     * A split audit file as stream factories: the first part followed by its continuation parts, in order.
+     * Every factory returns a fresh stream on every call, so the source can be read twice. The reader closes the streams it gets.
+     * @param {...[string, () => unknown]} parts
+     */
+    static fromFactories(...parts: [string, () => unknown][]): AuditfileSource;
+}
+/** One part of a source. */
+export declare class SourcePart {
+    #private;
+    /** Part number (1-based). */
+    number: any;
+    /** File or stream name. */
+    name: any;
+    /** True when the part can be opened more than once. */
+    reopenable: any;
+}
+/** Size, checksum and line count of a source part, known after it has been read once. */
+export declare class PartInfo {
+    /** Part number (1-based). */
+    number: any;
+    /** File or stream name. */
+    name: any;
+    /** Size in bytes. */
+    size: any;
+    /** SHA-256 of the bytes as read, lowercase hex. */
+    sha256: any;
+    /** Number of lines. */
+    lines: any;
+}

package/types/reading/value-converter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Empty text becomes null. Returns `{ ok: false }` when the text is not valid for the type.
+ * @param {string} raw
+ * @param {string} type One of {@link ColumnType}.
+ * @returns {{ ok: boolean, value: unknown }}
+ */
+export declare function tryConvert(raw: string, type: string): {
+    ok: boolean;
+    value: unknown;
+};
+/**
+ * Text form of a value for keys and messages: dates as yyyy-mm-dd, decimals as written.
+ * @param {unknown} value
+ */
+export declare function toText(value: unknown): string;

package/types/schema/schema.d.ts

@@ -0,0 +1,116 @@
+import { ManifestKey, ManifestReference } from '../definitions/manifest.js';
+import { AuditfileVersion } from '../versioning/version.js';
+/** How the version of an import was determined. */
+export declare const VersionSource: Readonly<{
+    /** The file uses the official namespace. */
+    Official: "official";
+    /** The file uses a known alias namespace. */
+    Alias: "alias";
+    /** The caller forced the version. */
+    Forced: "forced";
+    /** The resolver derived the version from the namespace. */
+    Resolved: "resolved";
+}>;
+/**
+ * The schema of one import: tables, columns, types, keys, references, row counts and origin.
+ * This is the contract everything after the reader builds on, regardless of where the data is stored.
+ * Converts to and from JSON without loss (definitions are re-attached from the version when known).
+ */
+export declare class AuditfileSchema {
+    #private;
+    /** Version key, e.g. "xaf/3.2". */
+    versionKey: any;
+    /** @type {AuditfileVersion | null} The version, or null when this reader does not know it (schema loaded from JSON). */
+    version: AuditfileVersion | null;
+    /** Namespace as found in the file. */
+    namespace: any;
+    /** How the version was determined, one of {@link VersionSource}. */
+    source: any;
+    /** Name of the applied dialect, or null. */
+    dialect: any;
+    /** True when the row count is known for every table. */
+    hasRowCounts: any;
+    /** @type {readonly SchemaTable[]} All tables in document order. */
+    tables: readonly SchemaTable[];
+    /**
+     * Finds a table by name, or returns null.
+     * @param {string} name
+     * @returns {SchemaTable | null}
+     */
+    findTable(name: string): SchemaTable | null;
+    /**
+     * Returns a table by name.
+     * @param {string} name
+     * @throws {RangeError} The table does not exist.
+     */
+    table(name: string): SchemaTable;
+    /** Serializes the schema to compact JSON, e.g. for storage in a database. */
+    toJson(): string;
+    /**
+     * Reads a schema written by {@link AuditfileSchema#toJson}.
+     * @param {string} json
+     * @throws {SyntaxError} The JSON is not a valid schema, or uses a format version, column type or version source this reader does not know.
+     */
+    static fromJson(json: string): AuditfileSchema;
+}
+/** A table of an import. */
+export declare class SchemaTable {
+    #private;
+    /** Table name, e.g. "tr_line". */
+    name: any;
+    /** Element name, e.g. "trLine". */
+    xmlName: any;
+    /** Full XML path. */
+    path: any;
+    /** Parent table name, or null for the root. */
+    parent: any;
+    /** Minimum occurrences relative to the XML parent element. */
+    minOccurs: any;
+    /** Maximum occurrences relative to the XML parent element; null means unbounded. */
+    maxOccurs: any;
+    /** Required by the standard. */
+    isRequired: any;
+    /** Expected in practice. */
+    isExpected: any;
+    /** Number of rows, when known from the scan phase; otherwise null. */
+    rowCount: any;
+    /** Position in the schema. */
+    index: any;
+    /** @type {readonly SchemaColumn[]} Columns; {@link AuditfileRow#values} uses the same order. */
+    columns: readonly SchemaColumn[];
+    /** @type {readonly ManifestKey[]} Natural keys. */
+    keys: readonly ManifestKey[];
+    /** @type {readonly ManifestReference[]} References to keys of other tables. */
+    references: readonly ManifestReference[];
+    /** @type {import('../definitions/element-definition.js').ElementDefinition | null} Documentation, when available. */
+    definition: import('../definitions/element-definition.js').ElementDefinition | null;
+    /**
+     * Finds a column by name, or returns null.
+     * @param {string} name
+     * @returns {SchemaColumn | null}
+     */
+    findColumn(name: string): SchemaColumn | null;
+    toString(): any;
+}
+/** A column of an import table. */
+export declare class SchemaColumn {
+    /** Column name. */
+    name: any;
+    /** Element or attribute name. */
+    xmlName: any;
+    /** Path relative to the table element. */
+    path: any;
+    /** "element" or "attribute". */
+    kind: any;
+    /** Logical type, one of {@link ColumnType}; determines the JavaScript type of the value. */
+    type: any;
+    /** XSD type name. */
+    xsdType: any;
+    /** Minimum occurrences relative to the XML parent element. */
+    minOccurs: any;
+    /** Position in {@link AuditfileRow#values}. */
+    index: any;
+    /** @type {import('../definitions/element-definition.js').ElementDefinition | null} Documentation, when available. */
+    definition: import('../definitions/element-definition.js').ElementDefinition | null;
+    toString(): any;
+}

package/types/sinks/sink.d.ts

@@ -0,0 +1,59 @@
+/** What a sink needs from the reader (bit flags). */
+export declare const SinkCapabilities: Readonly<{
+    /** Nothing special. */
+    None: 0;
+    /** The sink wants row counts before the first row (e.g. to pre-allocate); the reader scans first. */
+    NeedsRowCounts: 1;
+}>;
+export type Sink = {
+    /**
+     * What the sink needs, as {@link SinkCapabilities} flags.
+     */
+    capabilities?: number;
+    /**
+     * Start of an import. The schema contains row counts when the reader scanned first.
+     */
+    begin: (context: ImportContext) => void | Promise<void>;
+    /**
+     *   A batch of rows of one table. Child rows can arrive before their parent row; ids are already assigned.
+     */
+    write: (table: import('../schema/schema.js').SchemaTable, rows: readonly import('../reading/row.js').AuditfileRow[]) => void | Promise<void>;
+    /**
+     * The import is complete; commit.
+     */
+    complete: (report: import('../diagnostics/report.js').AuditfileReport) => void | Promise<void>;
+    /**
+     * The import failed; discard everything received since begin.
+     */
+    abort: (report: import('../diagnostics/report.js').AuditfileReport) => void | Promise<void>;
+};
+/**
+ * Receives an import: first the schema, then rows per table in batches, then completion or abort.
+ * All validation, merging and reporting happens before the sink, so a custom sink gets the same result as a built-in one.
+ * Every method may return a promise.
+ *
+ * @typedef {object} Sink
+ * @property {number} [capabilities] What the sink needs, as {@link SinkCapabilities} flags.
+ * @property {(context: ImportContext) => void | Promise<void>} begin Start of an import. The schema contains row counts when the reader scanned first.
+ * @property {(table: import('../schema/schema.js').SchemaTable, rows: readonly import('../reading/row.js').AuditfileRow[]) => void | Promise<void>} write
+ *   A batch of rows of one table. Child rows can arrive before their parent row; ids are already assigned.
+ * @property {(report: import('../diagnostics/report.js').AuditfileReport) => void | Promise<void>} complete The import is complete; commit.
+ * @property {(report: import('../diagnostics/report.js').AuditfileReport) => void | Promise<void>} abort The import failed; discard everything received since begin.
+ */
+/** Information at the start of an import. */
+export declare class ImportContext {
+    /** @type {import('../schema/schema.js').AuditfileSchema} The import schema. */
+    schema: import('../schema/schema.js').AuditfileSchema;
+    /** @type {readonly import('../reading/source.js').SourcePart[]} The source parts. */
+    parts: readonly import('../reading/source.js').SourcePart[];
+}
+/** Discards everything; used for validation. */
+export declare const NULL_SINK: Readonly<{
+    capabilities: 0;
+    begin(): void;
+    write(): void;
+    complete(): void;
+    abort(): void;
+}>;
+/** @param {unknown} sink */
+export declare function checkSink(sink: unknown): unknown;

package/types/validation/reference-checker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks keys (unique) and references (existing) from the schema.
+ * Only key values and unresolved reference values are kept in memory; references are resolved at the end,
+ * so a reference to a key that appears later (e.g. in a later part) is still found.
+ */
+export declare class ReferenceChecker {
+    #private;
+    constructor(schema: any, diagnostics: any);
+    onRow(row: any): void;
+    onEnd(): void;
+}

package/types/validation/xaf-rules.d.ts

@@ -0,0 +1,13 @@
+/** Audit file type these rules apply to. */
+export declare const XAF = "xaf";
+/**
+ * Business rules for Auditfile Financieel (XAF):
+ * every transaction balances, and the counts and totals in the headers match the lines.
+ * Rules whose tables or columns do not exist in a version are skipped. Columns are looked up once, not per row.
+ */
+export declare class XafRules {
+    #private;
+    constructor(schema: any, diagnostics: any);
+    onRow(row: any): void;
+    onEnd(): void;
+}

package/types/versioning/version-resolver.d.ts

@@ -0,0 +1,25 @@
+import { AuditfileVersion } from './version.js';
+/** The outcome of version resolution. */
+export declare class Resolution {
+    /** @type {AuditfileVersion} */
+    version: AuditfileVersion;
+    source: any;
+    fileNamespace: any;
+    /** @type {import('../definitions/dialect.js').Dialect | null} Set later when header/softwareDesc selects a dialect. */
+    dialect: import('../definitions/dialect.js').Dialect | null;
+    constructor(version: any, source: any, fileNamespace: any, dialect: any);
+    get needsMapping(): boolean;
+    /**
+     * Recognizes a dialect by the software description in the header, when none was recognized by namespace.
+     * Returns true when a dialect was found.
+     * @param {string} software
+     * @param {boolean} applyDialects
+     */
+    useSoftware(software: string, applyDialects: boolean): boolean;
+}
+/**
+ * Determines the version: forced by the caller, then the registry (official namespace, alias or dialect),
+ * then optionally the resolver. Anything else is fatal.
+ * @returns {Resolution | null}
+ */
+export declare function resolveVersion(rootName: any, fileNamespace: any, options: any, diagnostics: any): Resolution | null;

package/types/versioning/version.d.ts

@@ -0,0 +1,71 @@
+import { Dialect } from '../definitions/dialect.js';
+import { ElementDefinition } from '../definitions/element-definition.js';
+import { AuditfileManifest } from '../definitions/manifest.js';
+import { ViewDefinition } from '../definitions/view-definition.js';
+/**
+ * One audit file type and version, with its manifest, XSD, definitions and dialects.
+ * Use the constants, e.g. `AuditfileVersion.Financial.V3_2`, or {@link AuditfileVersion.parse} with "xaf/3.2".
+ */
+export declare class AuditfileVersion {
+    #private;
+    /** Registry key, e.g. "xaf/3.2". */
+    key: string;
+    /** Audit file type, e.g. "xaf". */
+    type: string;
+    /** Type name used for version objects, e.g. "financial". */
+    typeName: string;
+    /** Version, e.g. "3.2". */
+    version: string;
+    /** Folder of the definitions, e.g. "standards/xaf/3_2". */
+    folder: string;
+    /** Name of the root element. */
+    rootElement: string;
+    /** "official" or "reconstructed". */
+    provenance: string;
+    /** The official namespace. */
+    namespace: string;
+    /** @type {readonly string[]} Other namespaces known to be used for this version. */
+    aliases: readonly string[];
+    /** @type {readonly AuditfileVersion[]} All versions this reader knows, in registry order. */
+    static get all(): readonly AuditfileVersion[];
+    /** True when the XSD is the official one published by the Belastingdienst. */
+    get hasOfficialXsd(): boolean;
+    /** @type {AuditfileManifest} Structure: tables and columns. */
+    get manifest(): AuditfileManifest;
+    /** @type {ReadonlyMap<string, ElementDefinition>} Definitions by key ("tr_line", "tr_line.amnt"). */
+    get definitions(): ReadonlyMap<string, ElementDefinition>;
+    /** @type {readonly Dialect[]} Known dialects of this version. */
+    get dialects(): readonly Dialect[];
+    /** @type {readonly ViewDefinition[]} Views of this audit file type, e.g. the trial balance. Shared by all versions of the type. */
+    get views(): readonly ViewDefinition[];
+    /**
+     * Finds a view by name, or returns null.
+     * @param {string} name
+     */
+    findView(name: string): ViewDefinition | null;
+    /**
+     * Finds a version by key, e.g. "xaf/3.2" (case-insensitive). Returns null when unknown.
+     * @param {string} key
+     */
+    static find(key: string): AuditfileVersion | null;
+    /**
+     * Returns the version for a key such as "xaf/3.2".
+     * @param {string} key
+     * @throws {RangeError} The key is unknown.
+     */
+    static parse(key: string): AuditfileVersion;
+    /** The bytes of the XSD of this version. */
+    openXsd(): Uint8Array<ArrayBuffer>;
+    /** The compiled XSD of this version, ready for validation. Compiled once and shared; it is immutable. */
+    createSchemaSet(): any;
+    toString(): string;
+}
+export declare namespace AuditfileVersion {
+    var Financial: Readonly<{}>;
+    var CashRegister: Readonly<{}>;
+    var TaxiOnboardComputer: Readonly<{}>;
+    var TripRegistration: Readonly<{}>;
+    var Payroll: Readonly<{}>;
+}
+/** The groups of version constants, for the test that compares them with the registry. */
+export declare const VERSION_GROUPS: readonly string[];

package/types/views/view-result.d.ts

@@ -0,0 +1,13 @@
+/** The outcome of running a {@link ViewDefinition}. */
+export declare class ViewResult {
+    /** @type {import('../definitions/view-definition.js').ViewDefinition} The view that was run. */
+    view: import('../definitions/view-definition.js').ViewDefinition;
+    /** False when the version lacks a table or column the view needs (XAF-Q001); there are no rows then. */
+    isAvailable: any;
+    /** @type {readonly (readonly unknown[])[]} Result rows, sorted by the view's orderBy; one value per column. */
+    rows: readonly (readonly unknown[])[];
+    /** @type {readonly import('../diagnostics/diagnostic.js').Diagnostic[]} Findings while running the view. */
+    diagnostics: readonly import('../diagnostics/diagnostic.js').Diagnostic[];
+    /** Output columns; each row has one value per column, in this order. */
+    get columns(): readonly import("../definitions/view-definition.js").ViewColumn[];
+}

package/types/views/view-runner.d.ts

@@ -0,0 +1 @@
+export {};