/**
 * `<assert that="…" says="…"/>` — the attributes it cannot do without.
 *
 * An assertion is the one construct here whose whole worth is that it FAILS. A
 * half-written one is therefore worse than none at all: the config carries a
 * check, the reader believes the run was verified, and nothing was ever
 * compared. Both attributes are required, and an empty one counts as missing.
 *
 * The expression itself is not checked here. Both `that=` and `each=` are the
 * `if=` language, so each goes through the very same syntax check and the same
 * put-aside pass that resolves names once every sequence is known — a typo in a
 * column name is reported exactly as it would be in `if=`, because it IS the
 * same mistake.
 *
 * The two say different things and cannot be written together. `that=` reads
 * whole-run values ONCE; `each=` is answered on every row. A tag carrying both
 * would leave a reader to guess which of the two the sentence in `says=`
 * describes, and the answer would decide whether the run is checked once or a
 * million times.
 */
import { type Diagnostic } from '../errors/index.js';
import type { AttrContext, SelfClosingElementContext } from '../generated/TDCParser.js';
/** What this needs of the walk's context: somewhere to report, and the put-aside list. */
interface AssertSink {
    readonly diagnostics: Diagnostic[];
    rememberExpression(attr: AttrContext, expr: string): void;
}
/**
 * Check one `<assert>`: its two attributes here, its expression in two passes.
 *
 * The expression's names are put aside rather than resolved on the spot, because
 * an assertion may name a sequence declared below it and the run resolves that
 * happily — checking mid-walk would invent errors on configs that work.
 */
export declare function checkAssertTag(el: SelfClosingElementContext, sink: AssertSink): void;
export {};
//# sourceMappingURL=assert.d.ts.map