jsonisch 0.1.0

package/dist/plugin-BCsAE8RK.d.ts

@@ -0,0 +1,612 @@
+import { D as InternalFieldStore, F as ReadonlySignal, G as JsonSchema, I as Signal, K as Path, a as InternalFormStore, b as PluginKey, m as JsonischPlugin, t as FormRef, y as FieldSlotKey } from "./form-ref-D_xHSaqL.js";
+
+//#region src/core/types/derivation.d.ts
+
+/**
+ * The result of parsing a formula expression: the engine's opaque AST node,
+ * or a parse error. Shaped so a typical engine's parse result passes
+ * through unchanged — jsonisch itself never depends on the engine.
+ */
+type CalcParseResult = {
+  readonly ok: true;
+  readonly node: unknown;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * The injected calc engine, supplied by the host. Method syntax on
+ * purpose: bivariant parameters let the engine's concrete AST type satisfy
+ * the `unknown` node without an adapter layer —
+ * `{ parse: parseFormula, evaluate: evaluateFormula, extractDependencies,
+ * extractPathRefs }` passes through unchanged.
+ */
+interface CalcEngine {
+  /**
+   * Parses a formula expression into an opaque AST node. Called once per
+   * `x-formula` at store init.
+   */
+  parse(formula: string): CalcParseResult;
+  /**
+   * Evaluates a parsed node against a flat values scope. May throw (the
+   * `#ERROR` contract) — the derivation layer contains the throw to the
+   * field's own errors channel.
+   */
+  evaluate(node: unknown, scope: Record<string, unknown>): unknown;
+  /**
+   * Extracts the identifiers a formula reads: plain field refs plus
+   * collection names of aggregate refs (`SUM(assets[aiv])` → `assets`).
+   * Defines both the dep-graph edges and the eval-scope keys.
+   */
+  extractDependencies(node: unknown): string[];
+  /**
+   * Extracts `collection[field]` reference pairs. Optional: when present, a
+   * formula with at least one such reference is classified a rollup (the
+   * stricter-persistence set). A scalar root-record ref (`record[…]`) uses the
+   * same syntax and currently also flags — shape-aware refinement belongs
+   * to the persistence-rule slice.
+   */
+  extractPathRefs?(node: unknown): ReadonlyArray<{
+    readonly collection: string;
+    readonly field: string;
+  }>;
+}
+/**
+ * The mode of a formula field that accepts an estimate: `estimate` holds
+ * the provisional manually-entered value (the field's own input signal);
+ * `formula` computes. Estimate-first chronology — the formula supersedes
+ * the estimate, never "overrides" it. Wire-compatible with the legacy
+ * `<key>Source` companion's `manual` (→ `estimate`) / `formula` modes; the
+ * companion decode itself is a later slice.
+ */
+type DerivationMode = "estimate" | "formula";
+/**
+ * The output of a formula field's derived signal. `error` is the calc
+ * error message (`null` when the evaluation succeeded); it feeds the
+ * field's composed `errors` channel, where `#ERROR` rendering picks it up.
+ */
+interface DerivedState {
+  readonly value: unknown;
+  readonly error: string | null;
+}
+//#endregion
+//#region src/plugins/envelopes/types.d.ts
+/**
+ * The persisted meta half of an estimate field. Wire `mode` uses the
+ * settled names (`estimate` / `formula`). `manualValue` preserves the
+ * typed estimate across a mode flip; `lastFlippedAt` is stamped only when
+ * the mode actually changes. Server recompute may write a PARTIAL meta
+ * (`{ mode: "formula" }` only) — every reader tolerates that.
+ */
+interface EstimateMeta {
+  mode?: DerivationMode;
+  manualValue?: unknown;
+  lastFlippedAt?: string;
+}
+/**
+ * The persisted meta half of an amount-or-percent field. Wire `mode` is
+ * `amount` | `percent`; `basis` is the percent-of field key. The meta
+ * holds ONLY entry state — the value half is always the resolved dollar
+ * amount.
+ */
+interface EntryMeta {
+  mode?: EntryMode;
+  basis?: string;
+}
+/**
+ * The entry mode of an amount-or-percent field: enter a dollar `amount`,
+ * or a `percent` of the percent basis.
+ */
+type EntryMode = "amount" | "percent";
+/**
+ * In-memory estimate envelope (PR #553 kind union). `mode` is omitted
+ * when nothing was ever persisted — encode must not fabricate a pin.
+ */
+interface EstimateEnvelope {
+  readonly kind: "estimate";
+  readonly value?: unknown;
+  readonly mode?: DerivationMode;
+  readonly manualValue?: unknown;
+  readonly lastFlippedAt?: string;
+}
+/**
+ * In-memory amount-or-percent envelope. `mode` / `basis` are resolved
+ * (schema default applied) so dirty compare is `!==`, not re-defaulting.
+ */
+interface AmountOrPercentEnvelope {
+  readonly kind: "amount-or-percent";
+  readonly value?: unknown;
+  readonly mode: EntryMode;
+  readonly basis?: string;
+}
+type Envelope = EstimateEnvelope | AmountOrPercentEnvelope;
+/**
+ * The envelope slot of an estimate field (the `estimate` family). The mode
+ * signal is a computed over `envelope.mode` — write via `setMode` (the
+ * flip API), never by assigning `mode`.
+ */
+interface EstimateSlot {
+  readonly family: "estimate";
+  /**
+   * Live envelope. Written only by `writeEnvelope`.
+   */
+  readonly envelope: Signal<EstimateEnvelope>;
+  /**
+   * Dirty baseline / reset target. Reassigned on rebase and on
+   * `reset({ initialInput })`.
+   */
+  readonly startEnvelope: Signal<EstimateEnvelope>;
+  /**
+   * Resolved estimate/formula mode. An unpinned empty field follows
+   * `x-estimate-default-mode`; a stored unpinned value stays `estimate`.
+   */
+  readonly mode: ReadonlySignal<DerivationMode>;
+  /**
+   * The estimate value preserved when the mode flipped to formula this
+   * session (wire `manualValue` carry).
+   */
+  readonly manualValue: ReadonlySignal<unknown>;
+  /**
+   * The flip timestamp stamped this session, or the decoded one.
+   */
+  readonly lastFlippedAt: ReadonlySignal<string | undefined>;
+  /**
+   * Whether the meta half must serialize: the mode changed, or the
+   * estimate value did (an estimate keystroke dirties the meta with it).
+   */
+  readonly isDirty: ReadonlySignal<boolean>;
+  /**
+   * The identity-stable react callbacks the plugin's `fieldSnapshot`
+   * contributes, created lazily on first snapshot — a fresh closure per
+   * snapshot would defeat the equality gate and re-render every
+   * notification. Bound to form + path, which is safe because stores are
+   * position-fixed (array ops move values, not stores).
+   */
+  callbacks?: {
+    readonly setMode: (mode: DerivationMode) => void;
+  };
+}
+/**
+ * The envelope slot of an amount-or-percent field (the `amount-or-percent` family).
+ * Value edits never dirty the meta — only entry-state changes do.
+ */
+interface AmountOrPercentSlot {
+  readonly family: "amount-or-percent";
+  /**
+   * Live envelope. Written only by `writeEnvelope`.
+   */
+  readonly envelope: Signal<AmountOrPercentEnvelope>;
+  /**
+   * Dirty baseline / reset target. Reassigned on rebase and on
+   * `reset({ initialInput })`.
+   */
+  readonly startEnvelope: Signal<AmountOrPercentEnvelope>;
+  /**
+   * The current entry mode. An unpinned empty field follows
+   * `x-hybrid-default-mode`; a stored unpinned value stays `amount`.
+   */
+  readonly entryMode: ReadonlySignal<EntryMode>;
+  /**
+   * The current percent basis (a root-level field key), or `undefined` when the
+   * schema declares no default and none was stored.
+   */
+  readonly percentBasis: ReadonlySignal<string | undefined>;
+  /**
+   * Whether the meta half must serialize (entry mode or basis changed).
+   */
+  readonly isDirty: ReadonlySignal<boolean>;
+  /**
+   * The identity-stable react callbacks (see `EstimateSlot.callbacks`).
+   */
+  callbacks?: {
+    readonly setEntryMode: (mode: EntryMode) => void;
+    readonly setPercentBasis: (percentBasis: string) => void;
+  };
+}
+/**
+ * The envelope slot a value field may carry: meta state that is
+ * dirty-tracked and serialized by the envelopes plugin, never rendered as
+ * a field.
+ */
+type EnvelopeSlot = EstimateSlot | AmountOrPercentSlot;
+//#endregion
+//#region src/core/form/validate-form-input.d.ts
+/**
+ * Configuration for validating the form input.
+ */
+interface ValidateFormInputConfig {
+  /**
+   * Whether to focus the first field with an error.
+   */
+  readonly shouldFocus?: boolean | undefined;
+}
+/**
+ * The result of validating the form input.
+ */
+interface ValidationResult {
+  /**
+   * Whether the input passed validation.
+   */
+  readonly success: boolean;
+  /**
+   * The validated form input (the current tree input — AJV does not
+   * transform).
+   */
+  readonly output: unknown;
+}
+/**
+ * Validates the form input using the injected validator. Runs the validator
+ * against the current tree input, routes each issue's `instancePath` to its
+ * field store's `errors` signal (accumulating multiple issues per field,
+ * clearing every other field), and optionally focuses the first field with
+ * an error. A form without a validator always validates successfully.
+ *
+ * @param internalFormStore The form store to validate.
+ * @param config The validation configuration.
+ *
+ * @returns The validation result.
+ */
+declare function validateFormInput(internalFormStore: InternalFormStore, config?: ValidateFormInputConfig): ValidationResult;
+//#endregion
+//#region src/plugins/envelopes/plugin.d.ts
+/**
+ * The envelopes plugin's state: one slot per estimate/amount-or-percent
+ * value store, keyed by store identity.
+ */
+type EnvelopeState = Map<InternalFieldStore, EnvelopeSlot>;
+/**
+ * The envelopes plugin: owns the meta half of estimate and
+ * amount-or-percent fields — mode/entry state decoded from the kind
+ * envelope, dirty-tracked, and serialized by wrapping the field's own
+ * payload entry. No factory arguments: the envelope rides the field key,
+ * so every scope's raw value already carries the meta half (no envelope
+ * side-channel to decode).
+ */
+declare function envelopes(): JsonischPlugin<EnvelopeState>;
+declare module "../../react/types" {
+  interface FieldStoreSlots {
+    /**
+     * The estimate/formula mode of an estimate field, `undefined`
+     * otherwise.
+     */
+    readonly mode: DerivationMode | undefined;
+    /**
+     * Flips an estimate field's mode (the `setMode` method — seeds the
+     * estimate from the last formula result, stamps the meta half).
+     * Contributed only for estimate fields.
+     */
+    readonly setMode: (mode: DerivationMode) => void;
+    /**
+     * The entry mode of an amount-or-percent field, `undefined` otherwise.
+     */
+    readonly entryMode: EntryMode | undefined;
+    /**
+     * Sets an amount-or-percent field's entry mode (dirties the meta
+     * half). Contributed only for amount-or-percent fields.
+     */
+    readonly setEntryMode: (mode: EntryMode) => void;
+    /**
+     * The percent basis of an amount-or-percent field (a root-level field key).
+     */
+    readonly percentBasis: string | undefined;
+    /**
+     * Sets an amount-or-percent field's percent basis (dirties the meta
+     * half). Contributed only for amount-or-percent fields.
+     */
+    readonly setPercentBasis: (percentBasis: string) => void;
+  }
+}
+//#endregion
+//#region src/plugins/derivation/key.d.ts
+/**
+ * The derivation slot of a formula/estimate value store.
+ */
+interface DerivationSlot {
+  /**
+   * The derived output dependents chain through and the field displays: a
+   * computed over the deps' input signals + `offFormValues`, resolved
+   * through the single scope path — mode-aware: an estimate pin holds the
+   * field's own input. NEVER written back into `input` — derived values
+   * are outputs, excluded from dirty and payload by construction.
+   */
+  readonly derived: ReadonlySignal<DerivedState>;
+  /**
+   * The always-computed formula result, IGNORING the estimate pin — the
+   * candidate value the estimate wrapper's nudge compares against and the
+   * seed for a formula→estimate flip. The same signal object as `derived`
+   * on a plain formula field.
+   */
+  readonly formulaValue: ReadonlySignal<DerivedState>;
+  /**
+   * Whether the formula references a collection (`SUM(assets[…])`) —
+   * classified statically at wire time. Marks the stricter-persistence
+   * set; carries no behavior in this slice.
+   */
+  readonly isRollup: boolean;
+}
+/**
+ * The derivation plugin's slot key. The scope resolvers and the react
+ * surface read derived state through this identity.
+ */
+declare const derivationKey: FieldSlotKey<DerivationSlot>;
+//#endregion
+//#region src/plugins/derivation/plugin.d.ts
+/**
+ * The derivation plugin's state: one slot per formula/estimate value
+ * store, keyed by store identity.
+ */
+type DerivationState = Map<InternalFieldStore, DerivationSlot>;
+/**
+ * The derivation plugin: parses every `x-formula` once per scope (the
+ * document root and each array row — it is scope, not machinery, that
+ * differs; LOS-596), breaks dependency cycles deterministically, and gives
+ * each formula field its `formulaValue`/`derived` slot plus the composed
+ * `errors` channel.
+ *
+ * Scope resolution lives HERE and only here (the LOS-514 closure — no
+ * other read path exists): per dependency, the form value wins (a formula
+ * dep resolves through its own derived signal, chaining fresh values),
+ * `offFormValues` fills only `undefined`, and when both sides are arrays
+ * the canonical rows merge with the live form rows (the collection
+ * overlay for aggregate refs).
+ *
+ * Declares `dependsOn: [envelopesKey]` — the estimate pin reads the mode
+ * signal the envelopes plugin creates; without it the pin would silently
+ * never engage and a manually pinned value would be overwritten by the
+ * next recompute (the D2 data-loss scenario), so a missing envelopes
+ * plugin is a startup error instead.
+ */
+declare function derivation(engine: CalcEngine): JsonischPlugin<DerivationState>;
+declare module "../../react/types" {
+  interface FieldStoreSlots {
+    /**
+     * The mode-aware derived output of a formula/estimate field (what the
+     * field displays; an estimate pin holds the input). `undefined` on
+     * non-derived fields or without the derivation plugin.
+     */
+    readonly derived: DerivedState | undefined;
+    /**
+     * The always-computed formula result of a formula/estimate field,
+     * ignoring the estimate pin — the nudge's candidate value.
+     */
+    readonly formulaValue: DerivedState | undefined;
+  }
+}
+//#endregion
+//#region src/plugins/visibility/plugin.d.ts
+/**
+ * The visibility plugin's key. It keeps no state (rules and computeds live
+ * on the field stores' base `visibleWhen`/`visible` members).
+ */
+declare const visibilityKey: PluginKey<null>;
+/**
+ * The visibility plugin: every field gated by an `allOf` `if/then/else`
+ * block on its OWN scope's schema gets a `visible` computed signal over the
+ * watched field's resolved value. Two scope kinds (LOS-722 extended
+ * visibility into rows — the spec's open question 3):
+ *
+ * - the root scope, whose rules come from the form schema's `allOf`;
+ * - an array-row scope, whose rules come from the ITEMS schema's `allOf`
+ *   (`buildNestedFieldItems` carries the related dataset's conditionals),
+ *   evaluated against THAT row's values — row A's trigger never gates
+ *   row B's field.
+ *
+ * Visibility gates RENDERING only: a hidden field keeps its state, stays
+ * in the dirty diff, and rides the payload. Fields without a rule get no
+ * signal — the public store reads that as always visible.
+ *
+ * Register AFTER derivation (array order): a WHEN watching a formula field
+ * resolves through its derived slot. No hard `dependsOn` — a form without
+ * a calc engine legitimately omits derivation, and the watched-value read
+ * falls back to the field's input.
+ */
+declare function visibility(): JsonischPlugin<null>;
+//#endregion
+//#region src/plugins/bagger/compute-scope.d.ts
+interface BaggerOptions {
+  bag?: string;
+  /**
+   * Second classification source for row collections, union-ed with the
+   * walked schema's own relation nodes (`collectionKeys`). The host passes
+   * its DATASET schema here: which record keys hold rows is a property of
+   * the record, not of the stage being rendered.
+   */
+  collectionsSchema?: JsonSchema;
+}
+/**
+ * `computeBag` is store-less, so the alias key arrives as an option here;
+ * the plugin threads `form.rootRecordAlias` through (the one home — the
+ * plugin deliberately has NO alias option of its own, so the alias writer
+ * and the row-scope reader can never disagree).
+ */
+interface ComputeBagOptions extends BaggerOptions {
+  rootRecordAlias?: string;
+}
+/**
+ * The record keys that hold relation ROWS, from both classification
+ * sources. The union is load-bearing in both directions:
+ *
+ * - `collectionsSchema` (the dataset schema) alone decides collections the
+ *   walked schema does not configure. A stage that renders no assets tray
+ *   still needs `assets` on the shelf as FLATTENED rows — left raw, every
+ *   bag-resident key (`assignmentFee`) reads undefined per row and
+ *   `SUM(assets[assignmentFee])` or a check silently computes 0.
+ * - The walked schema alone declares relations the dataset schema lacks:
+ *   registry-role slugs and fallback defs are synthesized per stage
+ *   (`buildStageSchemaFromConfig`), so replacing rather than union-ing
+ *   would drop those collections off the shelf.
+ */
+declare function collectionKeys(schema: JsonSchema, collectionsSchema?: JsonSchema): Set<string>;
+/**
+ * Merges a source row's `x-column` fields with its bag column — bag wins,
+ * per the `x-column` save-routing authority (AI.md: read = row spread over
+ * its `data`). INTACT merge only, no envelope unwrapping: a later task
+ * seeds form rows from this output, and unwrapping here would hand the
+ * store already-flattened envelope values, reproducing the LOS-461
+ * regression.
+ */
+declare function flattenSourceRow(row: Record<string, unknown>, bag: string): Record<string, unknown>;
+/**
+ * Computes the off-form value bag for a canonical record: every declared
+ * scalar and relation collection, bag-merged and envelope-unwrapped, plus
+ * an alias entry holding the whole computed scope (so a formula or
+ * widget can address `record.termMonths` as readily as bare `termMonths`).
+ */
+declare function computeBag(schema: JsonSchema, record: Record<string, unknown>, opts?: ComputeBagOptions): Record<string, unknown>;
+//#endregion
+//#region src/plugins/bagger/plugin.d.ts
+/**
+ * The bagger plugin's state: the computed shelf plus an id-keyed row index
+ * per many:true relation field, used to seed a row's declared keys with
+ * their canonical baseline. Single-pick relations (`many: false`) hold a
+ * ref object, not a row collection, so they have no rows to index.
+ */
+interface BaggerState {
+  readonly scope: Record<string, unknown>;
+  readonly rowsByField: Map<string, Map<string, Record<string, unknown>>>;
+}
+declare const baggerKey: PluginKey<BaggerState>;
+/**
+ * The bagger plugin: computes the off-form shelf once (`computeBag`) and
+ * owns `offFormValues`, then seeds every relation row's declared keys from
+ * its canonical row as an unedited baseline. Registration order:
+ * `[envelopes(), bagger(record), derivation?, visibility()]` — envelopes
+ * first so its slot already exists on every estimate/amount-or-percent leaf by the
+ * time seeding runs (`dependsOn: [envelopesKey]` enforces this at
+ * `createFormStore`).
+ */
+declare function bagger(record: Record<string, unknown>, opts?: BaggerOptions): JsonischPlugin<BaggerState>;
+//#endregion
+//#region src/plugins/checks/types.d.ts
+type Severity = "info" | "warning" | "error";
+type SeverityConfig = Severity | "off";
+interface Finding {
+  /** Instance id — the bespoke.check row id. */
+  readonly id: string;
+  /** Definition id — "formula", … */
+  readonly checkId: string;
+  readonly messageId?: string;
+  /** Already interpolated. */
+  readonly message: string;
+  /** Display title (instance options.name, else the definition id). */
+  readonly name: string;
+  /** From config. A check cannot set this. */
+  readonly severity: Severity;
+  /** Field this finding attaches to; `[]` means form-level. */
+  readonly path: Path;
+}
+interface CheckScope {
+  /**
+   * One key through the derivation closure (LOS-514): when BOTH the
+   * canonical side and the live side are arrays, mergeCollectionRows;
+   * otherwise live wins and offForm / plugin collections fill only
+   * `undefined`. A root-record ref like `record` is a plain object — get
+   * returns that object, never an empty array.
+   */
+  get(key: string): unknown;
+  /**
+   * `get(collection)` when the value is an array, else `[]`. Never forces
+   * a non-array live value through the collection merge.
+   */
+  rows(collection: string): readonly Readonly<Record<string, unknown>>[];
+  /**
+   * The whole bag. Frozen; building it subscribes to every root key.
+   */
+  values(): Readonly<Record<string, unknown>>;
+}
+interface FindingDescriptor {
+  readonly messageId?: string;
+  readonly message?: string;
+  readonly data?: Readonly<Record<string, string | number>>;
+  /** Field(s) the finding attaches to. Empty/omitted → form-level. */
+  readonly paths?: readonly Path[];
+}
+interface CheckContext<Options = unknown> {
+  readonly id: string;
+  readonly checkId: string;
+  readonly options: Options;
+  readonly scope: CheckScope;
+  report(finding: FindingDescriptor): void;
+}
+interface CheckMeta<Options = unknown> {
+  readonly name: string;
+  readonly messages: Readonly<Record<string, string>>;
+  readonly optionsSchema?: Record<string, unknown> | false;
+  readonly defaultOptions?: Options;
+}
+interface CheckHandlers {
+  evaluate(): void;
+}
+interface CheckDefinition<Options = unknown> {
+  readonly meta: CheckMeta<Options>;
+  create(context: CheckContext<Options>): CheckHandlers;
+}
+interface CheckInstanceConfig<Options = unknown> {
+  readonly id: string;
+  readonly check: string;
+  readonly severity: SeverityConfig;
+  readonly options?: Options;
+}
+interface ChecksConfig {
+  readonly definitions: Readonly<Record<string, CheckDefinition<unknown>>>;
+  readonly instances: readonly CheckInstanceConfig[];
+  /**
+   * Canonical collection rows for CheckScope only (legacy host
+   * `evalCollections`). Must not be written onto the form's offForm shelf.
+   */
+  readonly collections?: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
+}
+interface FormulaOptions {
+  readonly formula: string;
+  readonly message?: string;
+  readonly name?: string;
+  readonly targetFieldKeys?: readonly string[];
+}
+//#endregion
+//#region src/plugins/checks/key.d.ts
+interface ChecksState {
+  readonly findings: ReadonlySignal<readonly Finding[]>;
+  readonly hasBlockingFinding: ReadonlySignal<boolean>;
+  /**
+   * Per-instance finding computeds. `replaceCheckInstances` swaps this
+   * signal's value so live admin edits rebind without remounting the form.
+   */
+  readonly instances: Signal<readonly ReadonlySignal<Finding[]>[]>;
+  /**
+   * Canonical collection rows for CheckScope (legacy `evalCollections`).
+   * Reactive so replace can refresh them with the instances.
+   */
+  readonly collections: Signal<Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>>;
+}
+declare const checksKey: PluginKey<ChecksState>;
+//#endregion
+//#region src/plugins/checks/formula.d.ts
+/** Shared messageId for parse/eval failures (plugin catch + host mapping). */
+declare const UNEVALUABLE_MESSAGE_ID = "unevaluable";
+/**
+ * The one built-in check definition: a `bespoke.check` row is an *instance*
+ * of this, not a definition of its own (ANALYSIS-eslint.md §2.6).
+ */
+declare function formulaCheck(engine: CalcEngine): CheckDefinition<FormulaOptions>;
+//#endregion
+//#region src/plugins/checks/plugin.d.ts
+/**
+ * Checks plugin (LOS-605 / spec D8): eslint's contract on a form store.
+ * Findings are a parallel channel — they never merge into `errors`.
+ *
+ * Register after derivation so a check that reads a formula field resolves
+ * through its derived slot. Array order, not a hard `dependsOn` — a form
+ * without a calc engine legitimately omits derivation.
+ *
+ * Always register (even with zero instances). Live instance edits go through
+ * `replaceCheckInstances` so the host does not remount the form.
+ */
+declare function checks(config: ChecksConfig): JsonischPlugin<ChecksState>;
+/**
+ * Re-registers check instances on a live form store (admin edits, late
+ * prop arrival) without remounting. Swaps the per-instance computeds the
+ * `findings` signal already reads.
+ */
+declare function replaceCheckInstances(form: FormRef, config: ChecksConfig): void;
+//#endregion
+export { EnvelopeState as A, EnvelopeSlot as B, flattenSourceRow as C, derivation as D, DerivationState as E, AmountOrPercentEnvelope as F, CalcParseResult as G, EstimateMeta as H, AmountOrPercentSlot as I, DerivationMode as K, EntryMeta as L, ValidateFormInputConfig as M, ValidationResult as N, DerivationSlot as O, validateFormInput as P, EntryMode as R, computeBag as S, visibilityKey as T, EstimateSlot as U, EstimateEnvelope as V, CalcEngine as W, bagger as _, ChecksState as a, ComputeBagOptions as b, CheckDefinition as c, ChecksConfig as d, Finding as f, BaggerState as g, SeverityConfig as h, formulaCheck as i, envelopes as j, derivationKey as k, CheckInstanceConfig as l, Severity as m, replaceCheckInstances as n, checksKey as o, FormulaOptions as p, DerivedState as q, UNEVALUABLE_MESSAGE_ID as r, CheckContext as s, checks as t, CheckScope as u, baggerKey as v, visibility as w, collectionKeys as x, BaggerOptions as y, Envelope as z };