/**
 * Centralised lists of "known" names the validator compares against.
 *
 * These are the single source of truth the validator uses for typo
 * suggestions. Keep them in sync with the actual implementation:
 *   - Gen types — src/sequence/build.ts buildGenValues switch
 *   - Template paths — src/templates/resolver.ts REGISTRY + date.ts
 *   - Operators — src/expr/evaluate.ts applyBinary / applyUnary switches
 *   - Builtin sequences — src/sequence/build.ts buildSequences
 *   - Fixture tags — src/processor/render.ts extractEnvConfig
 */
export declare const KNOWN_GEN_TYPES: readonly string[];
/**
 * Template paths baked into the registry. `person.b_day` and `date.range`
 * are registered dynamically by generators/date.ts at module-load time;
 * listing them here keeps the validator's view of "known paths" complete
 * without having to run the registry's side effects.
 */
export declare const KNOWN_TEMPLATE_PATHS: readonly string[];
/** Template paths that are builtin generators (not per-locale pack data). */
export declare const BUILTIN_TEMPLATE_PATHS: readonly string[];
/**
 * A template `value` that interpolates a field — `value="common.vehicle.model.${{Brand}}"`.
 * The concrete address is only known per row at render time (it depends on the
 * parent value drawn), so it can't be checked against the static pack list.
 */
export declare function isDynamicTemplateValue(value: string): boolean;
/**
 * A `type="template"` value is "known" if it is a builtin generator, a hard
 * pack address (exact), or a soft shape — some `<locale>.<path>` exists in the
 * loaded packs (the concrete locale is resolved against the env at render time).
 */
export declare function templatePathKnown(path: string, packAddresses: readonly string[]): boolean;
/**
 * The locales that ship a soft template path, e.g. `person.lastName` → `en`,
 * `ru`, … Empty when the path is a builtin, an absolute address, or nowhere.
 *
 * A path is validated against the locale the run will actually use, not
 * against "some locale has it": `check` used to pass a config the run then
 * refused with "unknown template path", which is the one thing a validator
 * exists to prevent.
 */
export declare function localesHavingPath(path: string, packAddresses: readonly string[]): readonly string[];
/**
 * Every path a config may legally write, given the packs that were loaded: the
 * addresses themselves (`usa.geo.city`) and their locale-free shapes
 * (`geo.city`, which resolves against the env locale at render time).
 *
 * TDC071's hint used to list the nine canonical shapes and call them "known
 * paths", which is what a reader who wrote `usa.geo.province` sees — while
 * `usa.geo.city`, absent from that list, works. The list was not a list of
 * known paths at all; it was a list of paths every locale happens to ship.
 */
export declare function candidateTemplatePaths(packAddresses: readonly string[]): readonly string[];
/**
 * The paths that sit beside `path` under the same namespace — what the author
 * most likely meant when they invented a leaf name their country does not use.
 * `usa.geo.province` → `usa.geo.city`, `usa.geo.county`, `usa.geo.state`, …
 */
export declare function siblingTemplatePaths(path: string, packAddresses: readonly string[]): readonly string[];
export declare const SUPPORTED_BINARY_OPERATORS: readonly string[];
export declare const SUPPORTED_UNARY_OPERATORS: readonly string[];
/**
 * The functions an `if=` expression may call, and how many arguments each takes.
 *
 * `max` is the top of an INCLUSIVE range and `undefined` means variadic. The
 * implementations live in `expr/evaluate.ts`; a unit test pins that the two
 * lists name exactly the same functions, because a name that validates and does
 * not evaluate is the worst of both.
 *
 * Everything here is EXACT — it is built from arithmetic the IEEE-754 standard
 * pins down, so five implementations cannot disagree about it. Transcendental
 * functions (sin, cos, exp, log …) are deliberately absent: measured on one
 * machine, `tan(1)` already differs in its last bit between Node and Python,
 * and a comparison turns that bit into a different row. They arrive when TDC
 * ships its own implementations, the way it ships its own PRNG.
 */
export declare const EXPR_FUNCTIONS: Readonly<Record<string, {
    min: number;
    max: number | undefined;
}>>;
export declare const EXPR_FUNCTION_NAMES: readonly string[];
/**
 * Names that are not available and are not typos either.
 *
 * Someone who writes `besselj(_count)` knows exactly what they meant, and
 * telling them "did you mean beta?" is worse than saying nothing — edit
 * distance has no idea these name entirely different functions. They are
 * answered with the real reason instead.
 *
 * What is left here is the mathematics a data generator has no business
 * carrying: each of these is a project rather than a function, and none has
 * ever plausibly belonged in a row predicate. They stay so that a person who
 * reaches for one gets an answer rather than "unknown function".
 */
export declare const PLANNED_EXPR_FUNCTIONS: readonly string[];
export declare const BUILTIN_SEQUENCES: readonly string[];
/**
 * Every name a `<sequence>` may NOT take, alphabetically.
 *
 * Wider than `BUILTIN_SEQUENCES` because the two lists answer different
 * questions. That one is "what resolves HERE", and `_item` / `_item_id` resolve
 * only inside an `each=` line, so they are handed in separately where a
 * reference is checked. This one is "what is RESERVED", and a name is reserved
 * everywhere or nowhere — a config that declares `<sequence name="_item">` and
 * later writes an `each=` line has taken a name the engine needs.
 */
export declare const RESERVED_SEQUENCE_NAMES: readonly string[];
/**
 * Tag names valid as direct children of `<env>`.
 *
 * `switch`, `uniq` and `distinct` are handled by their own branches before the
 * fallback that consults this list, so leaving them out never produced a false
 * error — it produced a WRONG error: a typo like `<swich>` printed an
 * "Allowed:" list missing three legal tags, and the suggestion machinery,
 * comparing against the same list, stayed silent on the obvious fix.
 */
export declare const KNOWN_ENV_CHILDREN: readonly string[];
/** Tag names valid as direct children of `<tdc>`. */
export declare const KNOWN_TDC_CHILDREN: readonly string[];
/** Tag names valid as direct children of `<mix>`. */
export declare const KNOWN_MIX_CHILDREN: readonly string[];
/** Tag names valid as direct children of `<switch>`. */
export declare const KNOWN_SWITCH_CHILDREN: readonly string[];
/** Tag names valid as direct children of `<case>`. */
export declare const KNOWN_CASE_CHILDREN: readonly string[];
/**
 * Tag names valid as direct children of `<sequence>`.
 *
 * The last container to get a list, and the reason is worth recording: an
 * invented tag here was accepted in silence — `check` said `is valid`, exit 0,
 * the run went ahead — while the identical mistake one level up, inside
 * `<env>`, got TDC010 with the allowed names spelled out. A model reading the
 * second fixes it on the first try; reading nothing, it concludes the tag
 * exists and carries it from attempt to attempt.
 *
 * The list is short because a sequence body is: the generator(s), literal text
 * between them, a `<distinct>` wrapper grouping fields, or a `<compute>` that
 * derives the column from others.
 */
export declare const KNOWN_SEQUENCE_CHILDREN: readonly string[];
/** Tag names valid as direct children of `<block>`. */
export declare const KNOWN_BLOCK_CHILDREN: readonly string[];
/**
 * `<distinct>` and `<uniq>` mean two different things depending on where they
 * sit, and so hold two different sets of children.
 *
 * Inside a `<sequence>` they group the FIELDS of one record — `<gen>`s. At
 * `<env>` level they group whole COLUMNS, so their members are declarations:
 * sequences, mixes and switches. One list for both refused half the working
 * configs in the suite, which is how this comment came to be written.
 *
 * A `<member name="…"/>` used to be listed here too. Nothing ever read it: the
 * name let it past the unknown-child check, the group then wrapped no
 * sequences, and the author got TDC221 — a warning about a symptom, for a tag
 * that does nothing. It was never designed, documented or used by a fixture, so
 * it is gone rather than implemented.
 */
export declare const KNOWN_DISTINCT_CHILDREN: readonly string[];
/** Members of an `<env>`-level `<distinct>` / `<uniq>` group. */
export declare const KNOWN_ENV_GROUP_CHILDREN: readonly string[];
/**
 * Tag names valid as direct children of `<pool>`.
 *
 * Deliberately generous. A pool is a miniature `<env>`, and the risk here is
 * lopsided: too SHORT a list refuses configs that work today, while too long a
 * one merely leaves a little of the old silence in place. Anything on this list
 * that a pool cannot really hold already has a diagnostic of its own.
 */
export declare const KNOWN_POOL_CHILDREN: readonly string[];
/** Tag names valid inside a fixture (`<before>`, `<after>`, the delimiters…). */
/**
 * A fixture body is made of `<line>`s and nothing else.
 *
 * `data` used to be on this list, and the renderer only ever walked `<line>` —
 * so `<before><data>x</data></before>` validated and emitted nothing at all.
 * The list is what the "Allowed inside" note prints, so it has to say what the
 * renderer actually does.
 */
export declare const KNOWN_FIXTURE_CHILDREN: readonly string[];
/** Tag names valid inside the open/close form of `<gen>`. */
export declare const KNOWN_GEN_CHILDREN: readonly string[];
/**
 * What each container allows, for the "Allowed: …" note.
 *
 * TDC010 printed this list and TDC013 did not — it said "Move <row> to a valid
 * location", which does not say where. The list is the part a reader acts on,
 * so both codes carry it now.
 */
export declare const ALLOWED_CHILDREN: Readonly<Record<string, readonly string[]>>;
//# sourceMappingURL=known.d.ts.map