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

package/types/definitions/manifest.d.ts

@@ -0,0 +1,118 @@
+/** Logical type of a column; the values are the type names of auditfile-spec. */
+export declare const ColumnType: Readonly<{
+    /** Text (`string`). */
+    String: "string";
+    /** Exact decimal number (`Decimal`). */
+    Decimal: "decimal";
+    /** Whole number (`number`, always a safe integer). */
+    Integer: "integer";
+    /** Date without time (`Date` at midnight UTC). */
+    Date: "date";
+    /** Date and time (`Date`; a value without time zone is taken as UTC). */
+    DateTime: "datetime";
+    /** Time of day (`string` "HH:MM:SS"). */
+    Time: "time";
+    /** True or false (`boolean`). */
+    Boolean: "boolean";
+}>;
+/** @param {string} type */
+export declare function parseColumnType(type: string): string;
+/** The structure of one audit file version, from manifest.json. */
+export declare class AuditfileManifest {
+    #private;
+    /** Format version of manifest.json. */
+    formatVersion: any;
+    /** Audit file type, e.g. "xaf". */
+    standard: string;
+    /** Version, e.g. "3.2". */
+    version: string;
+    /** Official namespace. */
+    namespace: string;
+    /** Name of the root element. */
+    rootElement: string;
+    /** SHA-256 of the official XSD. */
+    xsdSha256: string;
+    /** Tables required by the XSD. */
+    requiredTables: readonly string[];
+    /** Tables optional in the XSD but expected in practice. */
+    expectedTables: readonly string[];
+    /** All tables in document order. */
+    tables: readonly ManifestTable[];
+    /**
+     * Finds a table by name, or returns null.
+     * @param {string} name
+     */
+    findTable(name: string): ManifestTable | null;
+}
+/** A table of the manifest. */
+export declare class ManifestTable {
+    /** Position in the manifest. */
+    index: any;
+    /** Table name, e.g. "tr_line". */
+    name: string;
+    /** Element name, e.g. "trLine". */
+    xmlName: string;
+    /** Full XML path, e.g. "auditfile/company/transactions/journal/transaction/trLine". */
+    path: string;
+    /** Name of the parent table, or null for the root. */
+    parent: string | null;
+    /** Minimum occurrences relative to the XML parent element. */
+    minOccurs: any;
+    /** Maximum occurrences relative to the XML parent element; null means unbounded. */
+    maxOccurs: any;
+    /** Natural keys. */
+    keys: readonly ManifestKey[];
+    /** References to keys of other tables. */
+    references: readonly ManifestReference[];
+    /** Columns in XSD order. */
+    columns: readonly ManifestColumn[];
+}
+/** A column of a manifest table. */
+export declare class ManifestColumn {
+    /** Position within the table. */
+    index: any;
+    /** Column name, e.g. "amnt". */
+    name: string;
+    /** Element or attribute name. */
+    xmlName: string;
+    /** Path relative to the table element: "amnt", "currency/curCode", "@attr" or ".". */
+    path: string;
+    /** "element" or "attribute". */
+    kind: string;
+    /** Logical type, one of {@link ColumnType}. */
+    type: string;
+    /** Name of the XSD type. */
+    xsdType: string;
+    /** Minimum occurrences relative to the XML parent element. */
+    minOccurs: any;
+}
+/** A natural key: the column values are unique within an import. */
+export declare class ManifestKey {
+    /** Key name from the XSD. */
+    name: string;
+    /** Key columns. */
+    columns: readonly string[];
+    /**
+     * @param {string} name
+     * @param {string[]} columns
+     */
+    constructor(name: string, columns: string[]);
+}
+/** A reference from columns of one table to a key of another table. */
+export declare class ManifestReference {
+    /** Reference name from the XSD. */
+    name: string;
+    /** Referencing columns. */
+    columns: readonly string[];
+    /** Referenced table. */
+    table: string;
+    /** Referenced key. */
+    key: string;
+    /**
+     * @param {string} name
+     * @param {string[]} columns
+     * @param {string} table
+     * @param {string} key
+     */
+    constructor(name: string, columns: string[], table: string, key: string);
+}

package/types/definitions/names.d.ts

@@ -0,0 +1,25 @@
+/** What a dialect correction does. Unknown actions are refused when the definitions are loaded. */
+export declare const DialectAction: Readonly<{
+    /** Read a file in `from` as the official namespace. */
+    ReplaceNamespace: "replaceNamespace";
+    /** A decimal comma becomes a point. */
+    DecimalComma: "decimalComma";
+    /** The time is removed from a date. */
+    DateFromDateTime: "dateFromDateTime";
+}>;
+/** How a view column aggregates its values. Unknown aggregates are refused when the definitions are loaded. */
+export declare const ViewAggregate: Readonly<{
+    Sum: "sum";
+    Count: "count";
+    Min: "min";
+    Max: "max";
+}>;
+/** How a view column gets its value from an input row. Unknown operators are refused when the definitions are loaded. */
+export declare const ViewOperator: Readonly<{
+    /** The value of the column. */
+    Column: "column";
+    /** The value when `by` is one of the codes, otherwise null. */
+    Only: "only";
+    /** The value, negated when `by` is one of the codes. */
+    Signed: "signed";
+}>;

package/types/definitions/resources.d.ts

@@ -0,0 +1,9 @@
+/** The files from auditfile-spec/generated/ that are embedded in this package (tools/embed-spec.mjs). */
+/** @param {string} name */
+export declare function exists(name: string): boolean;
+/** @param {string} name */
+export declare function readText(name: string): string;
+/** @param {string} name */
+export declare function readJson(name: string): any;
+/** The bytes of an embedded file as published. */
+export declare function readBytes(name: any): Uint8Array<ArrayBuffer>;

package/types/definitions/view-definition.d.ts

@@ -0,0 +1,85 @@
+import { LocalizedText } from './localized-text.js';
+/**
+ * A view from views/<type>.json: a report over the rows of an import, such as a trial balance.
+ * Run it with {@link ViewDefinition#run} on any store that can hand out the rows of a table.
+ */
+export declare class ViewDefinition {
+    /** View name, e.g. "trial_balance". */
+    name: string;
+    /** Display name. */
+    label: LocalizedText | null;
+    /** What the view shows. */
+    description: LocalizedText | null;
+    /** The table with one input row per row of the view (before grouping). */
+    source: string;
+    /** Tables joined to the source: an ancestor of the source, or a lookup on key columns. */
+    joins: readonly ViewJoin[];
+    /** Optional filters. */
+    parameters: readonly ViewParameter[];
+    /** Output columns. When any column aggregates, the other columns group. */
+    columns: readonly ViewColumn[];
+    /** Output column names to sort by, ascending. */
+    orderBy: readonly string[];
+    /** True when at least one column aggregates. */
+    get isAggregated(): boolean;
+    /**
+     * Runs the view. `rows` returns the rows of a table by name.
+     * `parameters` holds filter values by parameter name; null and undefined values are ignored.
+     * @param {import('../schema/schema.js').AuditfileSchema} schema
+     * @param {(table: string) => Iterable<import('../reading/row.js').AuditfileRow>} rows
+     * @param {Record<string, unknown> | Map<string, unknown> | null} [parameters]
+     * @param {'nl' | 'en'} [language]
+     * @returns {import('../views/view-result.js').ViewResult}
+     * @throws {TypeError} A parameter is unknown or its value cannot be converted.
+     */
+    run(schema: import('../schema/schema.js').AuditfileSchema, rows: (table: string) => Iterable<import('../reading/row.js').AuditfileRow>, parameters?: Record<string, unknown> | Map<string, unknown> | null, language?: 'nl' | 'en'): import('../views/view-result.js').ViewResult;
+    toString(): string;
+}
+/** A table joined to the source of a view. */
+export declare class ViewJoin {
+    /** Table name. */
+    table: string;
+    /** Equality conditions; empty means {@link ViewJoin#table} is an ancestor of the source. */
+    on: readonly ViewJoinCondition[];
+}
+/** One equality condition of a join, as "table.column" references. */
+export declare class ViewJoinCondition {
+    /** Column of the source or an earlier join. */
+    left: any;
+    /** Column of the joined table. */
+    right: any;
+    constructor(left: any, right: any);
+}
+/** An optional filter of a view. */
+export declare class ViewParameter {
+    /** Parameter name, e.g. "period_from". */
+    name: string;
+    /** Display name. */
+    label: LocalizedText | null;
+    /** The filtered column, as "table.column". */
+    column: string;
+    /** "=", "<", "<=", ">" or ">=". */
+    operator: string;
+}
+/** An output column of a view. */
+export declare class ViewColumn {
+    /** Column name. */
+    name: string;
+    /** Display name. */
+    label: LocalizedText | null;
+    aggregate: string | null;
+    /** The value per input row; null for a row count. */
+    value: ViewValue | null;
+}
+/** How a view column gets its value from an input row. */
+export declare class ViewValue {
+    /** How the value is taken from `column`, one of {@link ViewOperator}. */
+    operator: any;
+    /** The value column, as "table.column". */
+    column: any;
+    /** The column holding the code, as "table.column". */
+    by: any;
+    /** Codes for "only" (in) or "signed" (negative). */
+    codes: readonly any[];
+    constructor(operator: any, column: any, by: any, codes: any);
+}

package/types/diagnostics/collector.d.ts

@@ -0,0 +1,38 @@
+import { Diagnostic } from './diagnostic.js';
+/** Where a diagnostic applies. */
+export declare class Location {
+    part: any;
+    line: any;
+    position: any;
+    path: any;
+    constructor(part?: null, line?: null, position?: null, path?: null);
+    static NONE: Location;
+}
+/**
+ * Collects diagnostics, formats messages from diagnostics.json and caps the list.
+ * The counts per severity cover every diagnostic, also the ones left out of a full list,
+ * and a full list makes room for an error by dropping an info or warning, so errors are never hidden behind them.
+ */
+export declare class DiagnosticCollector {
+    #private;
+    /** Number of diagnostics per severity, including the ones left out. */
+    counts: {
+        info: number;
+        warning: number;
+        error: number;
+        fatal: number;
+    };
+    constructor(language: any, maximum: any);
+    /** @type {Diagnostic[]} The kept diagnostics, followed by XAF-X900 when some were left out. */
+    get items(): Diagnostic[];
+    get hasFatal(): boolean;
+    get hasErrors(): boolean;
+    /** True when diagnostics were left out of {@link DiagnosticCollector#items}. */
+    get isTruncated(): boolean;
+    /**
+     * @param {string} code
+     * @param {Location} location
+     * @param {Record<string, unknown>} [args]
+     */
+    add(code: string, location: Location, args?: Record<string, unknown>): void;
+}

package/types/diagnostics/diagnostic.d.ts

@@ -0,0 +1,37 @@
+/** Severity of a diagnostic, from least to most severe. */
+export declare const DiagnosticSeverity: Readonly<{
+    /** Information only. */
+    Info: "info";
+    /** Something to look at; the result is still usable. */
+    Warning: "warning";
+    /** The file does not meet the standard. */
+    Error: "error";
+    /** Reading stopped. */
+    Fatal: "fatal";
+}>;
+/**
+ * Orders severities: negative when `a` is less severe than `b`.
+ * @param {string} a
+ * @param {string} b
+ */
+export declare function compareSeverity(a: string, b: string): number;
+/** A finding about an audit file, with a stable code from auditfile-spec. */
+export declare class Diagnostic {
+    /** Code, e.g. "XAF-R001". */
+    code: any;
+    /** "xml", "version", "structure", "xsd", "rules", "dialect" or "view". */
+    layer: any;
+    /** Severity, one of {@link DiagnosticSeverity}. */
+    severity: any;
+    /** Message in the requested language. */
+    message: any;
+    /** Source part (1-based), when known; otherwise null. */
+    part: any;
+    /** Line number, when known; otherwise null. */
+    line: any;
+    /** Position on the line, when known; otherwise null. */
+    position: any;
+    /** XML path, when known; otherwise null. */
+    path: any;
+    toString(): string;
+}

package/types/diagnostics/report.d.ts

@@ -0,0 +1,32 @@
+/** Outcome of a scan, validation or read. */
+export declare class AuditfileReport {
+    #private;
+    /** @type {import('../schema/schema.js').AuditfileSchema | null} The import schema, or null when the version could not be determined. */
+    schema: import('../schema/schema.js').AuditfileSchema | null;
+    /** @type {readonly import('../reading/source.js').PartInfo[]} Source parts with size and SHA-256 (empty when a part was not read completely). */
+    parts: readonly import('../reading/source.js').PartInfo[];
+    /**
+     * @type {readonly import('./diagnostic.js').Diagnostic[]} The diagnostics, in the order they were found, at most `maxDiagnostics`
+     * plus XAF-X900 when more were found. A full list makes room for errors by leaving out infos and warnings; fatal diagnostics are always included.
+     */
+    diagnostics: readonly import('./diagnostic.js').Diagnostic[];
+    /** True when diagnostics were left out of {@link AuditfileReport#diagnostics}; {@link AuditfileReport#count} still counts them. */
+    isTruncated: any;
+    /** @type {ReadonlyMap<string, number>} Rows per table. */
+    rowCounts: ReadonlyMap<string, number>;
+    /** True when rows were handed to the sink and completed. */
+    loaded: any;
+    /** Time taken, in milliseconds. */
+    duration: any;
+    /** True when a fatal diagnostic was found: reading stopped. */
+    get hasFatal(): boolean;
+    /** True when an error or fatal diagnostic was found, also when it is not in a truncated {@link AuditfileReport#diagnostics}. */
+    get hasErrors(): boolean;
+    /** True when there are no errors and no fatal diagnostics. */
+    get isValid(): boolean;
+    /**
+     * Number of diagnostics with the given severity, including the ones left out of a truncated {@link AuditfileReport#diagnostics}.
+     * @param {string} severity One of {@link DiagnosticSeverity}.
+     */
+    count(severity: string): any;
+}

package/types/generated/spec.d.ts

@@ -0,0 +1,6 @@
+export declare const spec: {
+    repository: string;
+    tag: string;
+    commit: string;
+};
+export declare const files: Map<string, string>;

package/types/index.d.ts

@@ -0,0 +1,18 @@
+export { Auditfile, AuditfileReader } from './auditfile.js';
+export { Dialect, DialectCorrection } from './definitions/dialect.js';
+export { ElementDefinition } from './definitions/element-definition.js';
+export { LocalizedText, TextLanguage } from './definitions/localized-text.js';
+export { AuditfileManifest, ColumnType, ManifestColumn, ManifestKey, ManifestReference, ManifestTable } from './definitions/manifest.js';
+export { DialectAction, ViewAggregate, ViewOperator } from './definitions/names.js';
+export { ViewColumn, ViewDefinition, ViewJoin, ViewJoinCondition, ViewParameter, ViewValue } from './definitions/view-definition.js';
+export { compareSeverity, Diagnostic, DiagnosticSeverity } from './diagnostics/diagnostic.js';
+export { AuditfileReport } from './diagnostics/report.js';
+export { Decimal } from './internal/decimal.js';
+export { MemorySink } from './memory/memory-sink.js';
+export { ReadMode, ReadProgress } from './reading/read-options.js';
+export { AuditfileRow } from './reading/row.js';
+export { AuditfileSource, PartInfo, SourcePart } from './reading/source.js';
+export { AuditfileSchema, SchemaColumn, SchemaTable, VersionSource } from './schema/schema.js';
+export { ImportContext, SinkCapabilities } from './sinks/sink.js';
+export { AuditfileVersion } from './versioning/version.js';
+export { ViewResult } from './views/view-result.js';

package/types/internal/composite-key.d.ts

@@ -0,0 +1,2 @@
+/** Joins the values of composite keys, view groups and joins: a character that cannot occur in XML text. */
+export declare const SEPARATOR = "\u001F";

package/types/internal/decimal.d.ts

@@ -0,0 +1,55 @@
+/**
+ * An exact decimal number: a BigInt coefficient and a scale (digits after the point).
+ * Amounts are never floating point, so totals and balances are exact.
+ * The scale is kept as written: `Decimal.parse('100.00').toString()` is `'100.00'`.
+ */
+export declare class Decimal {
+    #private;
+    /**
+     * @param {bigint} coefficient
+     * @param {number} [scale]
+     */
+    constructor(coefficient: bigint, scale?: number);
+    /** Zero. */
+    static ZERO: Decimal;
+    /**
+     * Parses XSD notation: an optional sign, digits and an optional decimal point. No exponent, no grouping.
+     * Returns null when the text is not valid or outside the range of a .NET decimal.
+     * @param {string} text
+     * @returns {Decimal | null}
+     */
+    static parse(text: string): Decimal | null;
+    /**
+     * Converts a number, bigint, numeric string or Decimal.
+     * @param {Decimal | number | bigint | string} value
+     * @returns {Decimal}
+     */
+    static from(value: Decimal | number | bigint | string): Decimal;
+    /** The unscaled value. */
+    get coefficient(): bigint;
+    /** Digits after the decimal point. */
+    get scale(): number;
+    /** @param {Decimal} other */
+    add(other: Decimal): Decimal;
+    /** @param {Decimal} other */
+    subtract(other: Decimal): Decimal;
+    negate(): Decimal;
+    /**
+     * Compares by value: `1.0` equals `1.00`.
+     * @param {Decimal} other
+     * @returns {-1 | 0 | 1}
+     */
+    compareTo(other: Decimal): -1 | 0 | 1;
+    /** @param {unknown} other */
+    equals(other: unknown): boolean;
+    /** True when the value has no fractional part. */
+    get isInteger(): boolean;
+    /** The value with trailing fractional zeros removed: `1.50` becomes `1.5`. */
+    normalize(): Decimal;
+    /** Nearest JavaScript number; may lose precision. */
+    toNumber(): number;
+    /** Invariant notation with the scale as written, e.g. `-123.40`. */
+    toString(): string;
+    /** Serializes as a string so no precision is lost. */
+    toJSON(): string;
+}

package/types/internal/encoding.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The encoding of a document or part, from its byte order mark or XML declaration (UTF-8 when neither says otherwise),
+ * following the detection rules of XML 1.0 appendix F.
+ */
+export declare class PartEncoding {
+    #private;
+    /** Name as declared, e.g. "utf-8", "utf-16le", "ISO-8859-1". */
+    name: any;
+    bomLength: any;
+    /** Bytes per code unit: 1 for UTF-8 and single-byte encodings, 2 for UTF-16. */
+    unitSize: any;
+    bigEndian: any;
+    /** Upper-case name for messages, e.g. "UTF-8". */
+    get label(): any;
+    /** True when both decode the same way; labels such as "latin1" and "ISO-8859-1" are the same encoding. */
+    sameAs(other: any): boolean;
+    /**
+     * @param {Uint8Array} bytes The first bytes.
+     * @returns {PartEncoding}
+     */
+    static detect(bytes: Uint8Array): PartEncoding;
+    /**
+     * Number of bytes of a leading byte order mark and XML declaration.
+     * @param {Uint8Array} bytes
+     * @param {number} length Bytes to look at.
+     */
+    skipDeclaration(bytes: Uint8Array, length: number): any;
+}
+/** The declared encoding is not supported (XAF-X004). */
+export declare class XmlEncodingError extends Error {
+    encoding: any;
+    /** @type {number | null} The part, when one part differs from the first. */
+    part: number | null;
+    constructor(encoding: any, message?: string);
+}
+/**
+ * A continuation part in another encoding than the first part. The parts are decoded as one document,
+ * so it would be read as garbled text without any error; it is refused instead (XAF-X004).
+ */
+export declare class PartEncodingError extends XmlEncodingError {
+    part: any;
+    constructor(part: any, encoding: any, first: any);
+}

package/types/internal/json.d.ts

@@ -0,0 +1,17 @@
+/** @param {unknown} value */
+declare function isObject(value: unknown): boolean;
+/**
+ * @param {string} text
+ * @param {string} name
+ */
+export declare function parseObject(text: string, name: string): any;
+export declare function string(json: any, key: any): string;
+export declare function optionalString(json: any, key: any): string | null;
+export declare function int(json: any, key: any): any;
+export declare function optionalInt(json: any, key: any): any;
+export declare function bool(json: any, key: any): boolean;
+export declare function object(json: any, key: any): any;
+export declare function array(json: any, key: any): any[];
+export declare function objects(json: any, key: any): any[];
+export declare function strings(json: any, key: any): string[];
+export { isObject };

package/types/internal/sha256.d.ts

@@ -0,0 +1,17 @@
+export declare class Sha256 {
+    #private;
+    /** @param {Uint8Array} data */
+    update(data: Uint8Array): this;
+    /** Finishes the hash and returns it as lowercase hex. */
+    digestHex(): string;
+    /** @param {Uint8Array} data */
+    static hex(data: Uint8Array): any;
+    /**
+     * The fastest available implementation: Node's when present, this one otherwise.
+     * @returns {{ update(data: Uint8Array): unknown, digestHex(): string }}
+     */
+    static create(): {
+        update(data: Uint8Array): unknown;
+        digestHex(): string;
+    };
+}

package/types/internal/streams.d.ts

@@ -0,0 +1,35 @@
+import { PartInfo } from '../reading/source.js';
+/** A part could not be opened or read; reported as XAF-X002, never thrown to the caller. */
+export declare class SourceError extends Error {
+    part: any;
+    constructor(part: any, cause: any);
+}
+/**
+ * An async iterator over the chunks of any supported stream.
+ * With keepOpen the caller's stream is not destroyed when reading stops early.
+ * @returns {AsyncIterator<unknown>}
+ */
+export declare function iterate(stream: any, keepOpen: any): AsyncIterator<unknown>;
+/**
+ * Reads the parts of a source one after another as one document.
+ * For continuation parts a leading byte order mark and XML declaration are skipped; a part in another encoding
+ * than the first is refused (PartEncodingError), because it would be decoded with the encoding of the first part.
+ * Collects size, SHA-256 and line count per part when collectStatistics is set.
+ */
+export declare class ConcatenatedStream {
+    #private;
+    collectStatistics: boolean;
+    /** @type {PartInfo[]} Statistics of the parts read completely so far. */
+    completed: PartInfo[];
+    /** Number (1-based) of the part the most recent chunk came from. */
+    part: number;
+    /** Bytes handed out so far, over all parts. */
+    position: number;
+    /**
+     * @param {readonly import('../reading/source.js').SourcePart[]} parts
+     * @param {boolean} collectStatistics
+     */
+    constructor(parts: readonly import('../reading/source.js').SourcePart[], collectStatistics: boolean);
+    /** @returns {AsyncGenerator<Uint8Array>} */
+    chunks(): AsyncGenerator<Uint8Array>;
+}

package/types/internal/xml-reader.d.ts

@@ -0,0 +1,50 @@
+import { XmlEncodingError } from './encoding.js';
+/** Event kinds. */
+export declare const START = 1;
+export declare const END = 2;
+export declare const TEXT = 3;
+/** The document is not well-formed XML, or its bytes cannot be decoded. */
+export declare class XmlSyntaxError extends Error {
+    line: any;
+    column: any;
+    part: any;
+    constructor(message: any, line: any, column: any, part: any);
+}
+export { XmlEncodingError };
+/**
+ * Pull reader over a byte stream: start, text and end events with line, column, depth and source part.
+ * DTDs are refused, entities other than the five predefined ones are errors, and namespaces are resolved.
+ */
+export declare class XmlReader {
+    #private;
+    /** @param {import('./streams.js').ConcatenatedStream} stream */
+    /**
+     * @param {import('./streams.js').ConcatenatedStream} stream
+     * @param {{ maxCharacters?: number }} [limits] maxCharacters: characters in the whole document; 0 is no limit.
+     */
+    constructor(stream: import('./streams.js').ConcatenatedStream, { maxCharacters }?: {
+        maxCharacters?: number;
+    });
+    /** Bytes before the slice in which the root element starts; precise to one slice (64 KB). */
+    rootOffset: null;
+    /** Bytes handed to the parser so far. */
+    get position(): number;
+    /** The source part being parsed. */
+    get part(): number;
+    /** Presents one namespace as another, e.g. an alias as the official namespace. */
+    mapNamespace(from: any, to: any): void;
+    /**
+     * The next event when one is already parsed; undefined when the caller must await {@link XmlReader#next}.
+     * Saves a promise per event, which is most of the cost of a large file.
+     */
+    poll(): any;
+    /**
+     * The next event, or null at the end of the document.
+     * @throws {XmlSyntaxError | XmlEncodingError}
+     */
+    next(): Promise<any>;
+    /** Puts an event back so the next call returns it again. */
+    pushBack(event: any): void;
+    /** Stops reading and closes the streams it opened. */
+    close(): Promise<void>;
+}

package/types/memory/memory-sink.d.ts

@@ -0,0 +1,29 @@
+/** Keeps all rows in memory, per table. Useful for tests, small files and the browser. */
+export declare class MemorySink {
+    #private;
+    capabilities: 0;
+    /** @type {import('../schema/schema.js').AuditfileSchema | null} The import schema, after begin. */
+    schema: import('../schema/schema.js').AuditfileSchema | null;
+    /** @type {import('../diagnostics/report.js').AuditfileReport | null} The report, after completion or abort. */
+    report: import('../diagnostics/report.js').AuditfileReport | null;
+    /** True when the import was aborted; no rows are kept then. */
+    isAborted: boolean;
+    /**
+     * Rows of a table; empty when the table has no rows.
+     * @param {string} table
+     * @returns {readonly import('../reading/row.js').AuditfileRow[]}
+     */
+    rows(table: string): readonly import('../reading/row.js').AuditfileRow[];
+    /**
+     * Runs a view, e.g. `sink.run(sink.schema.version.findView('trial_balance'))`, over the rows in memory.
+     * @param {import('../definitions/view-definition.js').ViewDefinition} view
+     * @param {Record<string, unknown> | Map<string, unknown> | null} [parameters]
+     * @param {'nl' | 'en'} [language]
+     * @throws {Error} Nothing has been read yet.
+     */
+    run(view: import('../definitions/view-definition.js').ViewDefinition, parameters?: Record<string, unknown> | Map<string, unknown> | null, language?: 'nl' | 'en'): import("../index.js").ViewResult;
+    begin(context: any): void;
+    write(table: any, rows: any): void;
+    complete(report: any): void;
+    abort(report: any): void;
+}