ngx-t-forms-types 0.0.30 → 0.0.34

package/dist/skillet/internal/coupling.js

@@ -0,0 +1,69 @@
+import { s } from '@hashbrownai/core';
+/**
+ * Compile-time coupling primitives that bind the Skillet schemas to the
+ * interfaces they describe.
+ *
+ * The rule these enforce, stated once:
+ *
+ *   `s.Infer<node>` must be ASSIGNABLE TO the interface member's type.
+ *
+ * Assignability — not equality — is deliberate. A Skillet node is allowed to be
+ * NARROWER than the interface (we routinely refuse to let a model emit a `Date`
+ * object or a custom-script sentinel even where the interface permits one), but
+ * it may never be WIDER. Widening is precisely the drift that produces a value
+ * the rest of the codebase cannot hold, so that is the direction we fail on.
+ */
+/**
+ * Guards a Skillet node against the type it is meant to produce.
+ *
+ * Curried so the expected type is written explicitly and the node type is
+ * inferred:
+ *
+ * ```ts
+ * const colSize = matches<number>()(s.integer('Grid width', { minimum: 1 }));
+ * ```
+ *
+ * If the node's inferred output stops being assignable to `Expected` — because
+ * someone retyped the interface member, or loosened the node — the argument
+ * collapses to `never` and the call fails to compile.
+ */
+export function matches() {
+    return (node) => node;
+}
+/**
+ * Derives Skillet enum entries from a TypeScript string enum at runtime, so the
+ * two can never disagree: add a member to the enum and it appears in the schema
+ * on the next evaluation, with `s.Infer` widening to match.
+ *
+ * The `Record<string, string>` constraint rejects numeric and mixed enums —
+ * `Object.values` on those also yields the reverse-mapped numeric keys, which
+ * would silently poison the entry list. Skillet enumerations are string-only.
+ */
+export function enumValues(enumObject) {
+    return Object.values(enumObject);
+}
+/**
+ * Asserts a literal tuple covers a string union exactly.
+ *
+ * Needed for union *types* (`'hard' | 'soft'`), which — unlike enums — have no
+ * runtime representation to derive from, so the members must be restated. This
+ * makes restating them safe: drop one and the argument becomes `never`.
+ *
+ * ```ts
+ * const WRAP = exhaustive<'hard' | 'soft'>()(['hard', 'soft'] as const);
+ * ```
+ */
+export function exhaustive() {
+    return (entries) => entries;
+}
+/**
+ * Wraps a node as an absent-able member.
+ *
+ * Skillet has no `optional()`: every declared key must appear in the model's
+ * response. Optionality is therefore modelled as an explicit null branch — the
+ * key is always emitted, and `null` is how the model says "not set". Strip the
+ * nulls when converting a generated column into a `FormColumnInputs`.
+ */
+export function optional(node) {
+    return s.anyOf([node, s.nullish()]);
+}

package/dist/skillet/internal/editor-guidance.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Expressions this module could not read, exposed so a test can assert the set
+ * is empty.
+ *
+ * The grammar in use is closed — `key === value`, joined only by `||` — but it
+ * is a string, so nothing stops a future edit reaching for `&&` or `!==`.
+ * Rather than throw at import time and take a consumer's app down over editor
+ * copy, unreadable expressions are skipped and recorded here, which turns a
+ * silent loss of guidance into a failing test.
+ */
+export declare const UNREADABLE_EXPRESSIONS: string[];
+/**
+ * Composes the description for a property: the authored sentence, then the
+ * editor's hint where it adds something, then when the property applies.
+ *
+ * @param base authored, model-facing description of the property
+ * @param path the property's `deepBind` path — a single key for a top-level
+ *   member, a longer path for a member of a nested config
+ */
+export declare function describe(base: string, ...path: string[]): string;
+/**
+ * Composes a description for a member of a record edited by a SECONDARY
+ * editor — a preset filter within `workflowPickerConfig.presetFilters`, say.
+ *
+ * @param base authored, model-facing description of the property
+ * @param opensAt the `deepBind` path of the row that opens the editor
+ * @param path the property's path within the record being edited
+ */
+export declare function describeIn(base: string, opensAt: readonly string[], ...path: string[]): string;
+/**
+ * Numeric bounds the editor enforces on a property, ready to spread into a
+ * Skillet numeric node so the schema constrains what the settings panel does.
+ */
+export declare function rangeFor(...path: string[]): {
+    minimum?: number;
+    maximum?: number;
+} | undefined;
+/** Property paths the editor config carries guidance for. Used by tests. */
+export declare const GUIDED_PATHS: readonly string[];
+/**
+ * The top-level members the settings panel edits on EVERY element.
+ *
+ * A row named `SpecialElementKeys.Default` is not looked up in an element's
+ * `properties` at all: it is rendered for every element, gated only by its own
+ * `additionalTest` and `disabled` tests. So the members those rows edit are
+ * part of every element's surface in the builder while appearing in no
+ * element's property list — `readonly`, `onlySetTempErrorOnTouch` and
+ * `tourContent` among them. Read here so variant assembly can offer what the
+ * builder offers, from the same source the builder reads.
+ *
+ * Only ungated rows qualify. A gated row is conditional on a VALUE (`min`
+ * needs a numeric `type`; `calculatedFieldRules` needs the flag), which is not
+ * "always shown" and is handled elsewhere. Nested bindings (`script.onChange`,
+ * `matOptions.fetch.value.source`) are members of a nested object, not of the
+ * column, and are left to the modules that own those objects.
+ */
+export declare const ALWAYS_SHOWN_MEMBERS: readonly string[];
+/**
+ * Secondary-editor paths, as `openingPath -> propertyPath`. Used by tests to
+ * assert the nested editors are actually being reached: before these were
+ * collected, every hint inside a record-list editor was invisible here, and
+ * nothing failed to say so.
+ */
+export declare const SECONDARY_GUIDED_PATHS: ReadonlyMap<string, readonly string[]>;

package/dist/skillet/internal/editor-guidance.js

@@ -0,0 +1,291 @@
+import { SpecialElementKeys } from '../../interfaces/FormBuilder/FormInputKeys.js';
+import { getElementEditorConfig } from '../../interfaces/FormBuilder/inputConfig/ElementEditConfig.js';
+/** Joins a `deepBind` path into the key this module indexes rows by. */
+const pathKey = (path) => path.join('.');
+function collectRows() {
+    const rows = [];
+    for (const section of getElementEditorConfig.editorSections ?? []) {
+        for (const element of section.elements ?? []) {
+            rows.push(element);
+        }
+    }
+    return rows;
+}
+/**
+ * Rows belonging to a `secondaryElementEditorConfig`, indexed by the path of
+ * the row that opens them and then by their own path within that editor.
+ *
+ * ## Why these are indexed separately rather than prefixed into `rowsByPath`
+ *
+ * A secondary editor's rows bind RELATIVE to the record it edits, so making
+ * them globally addressable means prefixing them with something. The obvious
+ * prefix — the opening row's `deepBind` — is right in one case and wrong in the
+ * other, which is the whole reason for this split:
+ *
+ * - `workflowPickerConfig.presetFilters` opens a `RecordListManager` over the
+ *   filters themselves, so its inner `op` row really is
+ *   `workflowPickerConfig.presetFilters[].op`.
+ * - `mscoaConfig` opens a composite editor whose secondary rows edit
+ *   `dualCashExclusion.rules[]`, NOT `mscoaConfig` directly. Prefixing there
+ *   would file the dual-cash `pattern` hint under `mscoaConfig.pattern` — a
+ *   path nothing has, silently attaching accounting-exclusion guidance to
+ *   whatever member later claimed that name.
+ *
+ * Nothing on the row says which of the two it is, so rather than guess, the
+ * caller states the container it is describing and looks rows up within it.
+ * Keeping this index apart from `rowsByPath` also means top-level descriptions
+ * are unchanged by its existence.
+ */
+function collectSecondaryRows() {
+    const index = new Map();
+    for (const parent of collectRows()) {
+        const sections = parent.secondaryElementEditorConfig;
+        if (!sections?.length || !parent.deepBind?.length)
+            continue;
+        const parentKey = pathKey(parent.deepBind);
+        const inner = index.get(parentKey) ?? new Map();
+        for (const section of sections) {
+            for (const row of section.elements ?? []) {
+                if (!row.deepBind?.length)
+                    continue;
+                const key = pathKey(row.deepBind);
+                const existing = inner.get(key);
+                if (existing)
+                    existing.push(row);
+                else
+                    inner.set(key, [row]);
+            }
+        }
+        if (inner.size)
+            index.set(parentKey, inner);
+    }
+    return index;
+}
+/**
+ * Every editor row, indexed by its `deepBind` path.
+ *
+ * `name` is not the index: it reads `'default'` on most rows, with the property
+ * actually being edited carried in `deepBind`. Nested paths
+ * (`matOptions.fetch.options`) are indexed too, so the sub-schemas for the
+ * pending members can draw on the same guidance when they are built.
+ */
+const rowsByPath = (() => {
+    const index = new Map();
+    for (const row of collectRows()) {
+        if (!row.deepBind?.length)
+            continue;
+        const key = pathKey(row.deepBind);
+        const existing = index.get(key);
+        if (existing)
+            existing.push(row);
+        else
+            index.set(key, [row]);
+    }
+    return index;
+})();
+/**
+ * Expressions this module could not read, exposed so a test can assert the set
+ * is empty.
+ *
+ * The grammar in use is closed — `key === value`, joined only by `||` — but it
+ * is a string, so nothing stops a future edit reaching for `&&` or `!==`.
+ * Rather than throw at import time and take a consumer's app down over editor
+ * copy, unreadable expressions are skipped and recorded here, which turns a
+ * silent loss of guidance into a failing test.
+ */
+export const UNREADABLE_EXPRESSIONS = [];
+/**
+ * Renders one comparison as prose.
+ *
+ * `!==` is tested first because `===` is not a substring of it — splitting on
+ * `===` would leave `valueSource !` as the key and read the rule backwards,
+ * which is worse than not reading it at all.
+ */
+function readComparison(clause) {
+    const negated = clause.includes('!==');
+    const parts = clause.split(negated ? '!==' : '===');
+    if (parts.length !== 2)
+        return null;
+    const key = parts[0].trim();
+    const value = parts[1].trim();
+    if (!key || !value)
+        return null;
+    return { key, negated, value };
+}
+/**
+ * Turns one applicability test into a clause such as
+ * `type is number or date`, or `null` if it cannot be read.
+ */
+function readTest(test) {
+    if (test.expression) {
+        const expression = test.expression;
+        // `&&` remains unreadable. Unlike `!==`, it changes the SHAPE of the rule
+        // from "any of these" to "all of these", and every collapse below assumes
+        // alternatives — reading one as a disjunction would state the opposite of
+        // what the editor enforces.
+        if (expression.includes('&&')) {
+            UNREADABLE_EXPRESSIONS.push(expression);
+            return null;
+        }
+        const comparisons = expression.split('||').map(readComparison);
+        if (comparisons.some((c) => c === null)) {
+            UNREADABLE_EXPRESSIONS.push(expression);
+            return null;
+        }
+        const read = comparisons;
+        const phrase = (negated) => (negated ? 'is not' : 'is');
+        // Every clause in the observed grammar tests the same key against
+        // alternatives, which reads far better collapsed than repeated. Collapsing
+        // requires a shared operator as well as a shared key: `a === x || a !== y`
+        // states two different things about `a` and must stay spelled out.
+        const [first] = read;
+        const uniform = read.every((c) => c.key === first.key && c.negated === first.negated);
+        if (uniform) {
+            const values = read.map((c) => c.value);
+            const list = values.length === 1
+                ? values[0]
+                : `${values.slice(0, -1).join(', ')} or ${values[values.length - 1]}`;
+            return `${first.key} ${phrase(first.negated)} ${list}`;
+        }
+        return read
+            .map((c) => `${c.key} ${phrase(c.negated)} ${c.value}`)
+            .join(', or ');
+    }
+    if (test.testType === 'exists' && test.deepBind?.length) {
+        return `${pathKey(test.deepBind)} is set`;
+    }
+    return null;
+}
+/**
+ * Secondary-editor rows, indexed by opening path and then by their own path.
+ * See {@link collectSecondaryRows} for why these are kept out of
+ * {@link rowsByPath}.
+ */
+const secondaryRowsByParent = collectSecondaryRows();
+/** The applicability sentence for a property, if the editor declares one. */
+function applicabilityIn(rows) {
+    if (!rows?.length)
+        return undefined;
+    const clauses = rows
+        .flatMap((row) => row.additionalTest ?? [])
+        .map(readTest)
+        .filter((clause) => clause !== null);
+    const unique = [...new Set(clauses)];
+    if (!unique.length)
+        return undefined;
+    return `Only applies when ${unique.join(', or when ')}.`;
+}
+/**
+ * Collapses the whitespace a hint picked up from its source.
+ *
+ * Several hints are written as indented multi-line template literals, so they
+ * arrive carrying newlines and runs of leading spaces. Rendered into a schema
+ * description those become blank lines and stray gaps before punctuation, which
+ * is exactly the kind of noise that makes a long system prompt harder to read.
+ */
+const collapseWhitespace = (text) => text
+    .replace(/\s+/g, ' ')
+    .replace(/\s+([.,;:])/g, '$1')
+    // Pulling a hint flush can bring a stray trailing full stop up against the
+    // one ending the previous sentence — at least one hint is written with a
+    // lone `.` on its own line. Collapse the pair back to a single stop.
+    .replace(/([.!?])[\s]*\1+/g, '$1')
+    .trim();
+/** The authored hint for a property, if the editor carries one. */
+function hintIn(rows) {
+    const hint = rows
+        ?.map((row) => row.hint)
+        .find((h) => !!h?.trim());
+    return hint ? collapseWhitespace(hint) : undefined;
+}
+/** Ends a fragment with a full stop so composed sentences read cleanly. */
+const terminate = (text) => /[.!?]$/.test(text) ? text : `${text}.`;
+/**
+ * Composes the description for a property: the authored sentence, then the
+ * editor's hint where it adds something, then when the property applies.
+ *
+ * @param base authored, model-facing description of the property
+ * @param path the property's `deepBind` path — a single key for a top-level
+ *   member, a longer path for a member of a nested config
+ */
+export function describe(base, ...path) {
+    return compose(base, rowsByPath.get(pathKey(path)));
+}
+/**
+ * Composes a description for a member of a record edited by a SECONDARY
+ * editor — a preset filter within `workflowPickerConfig.presetFilters`, say.
+ *
+ * @param base authored, model-facing description of the property
+ * @param opensAt the `deepBind` path of the row that opens the editor
+ * @param path the property's path within the record being edited
+ */
+export function describeIn(base, opensAt, ...path) {
+    return compose(base, secondaryRowsByParent.get(pathKey(opensAt))?.get(pathKey(path)));
+}
+/** Shared body of {@link describe} and {@link describeIn}. */
+function compose(base, rows) {
+    const parts = [terminate(base)];
+    const hint = hintIn(rows);
+    // Skip a hint the authored text already covers, so composition cannot
+    // produce the same guidance twice in one description.
+    if (hint && !base.toLowerCase().includes(hint.toLowerCase())) {
+        parts.push(terminate(hint));
+    }
+    const applicability = applicabilityIn(rows);
+    if (applicability)
+        parts.push(applicability);
+    return parts.join(' ');
+}
+/**
+ * Numeric bounds the editor enforces on a property, ready to spread into a
+ * Skillet numeric node so the schema constrains what the settings panel does.
+ */
+export function rangeFor(...path) {
+    const rows = rowsByPath.get(pathKey(path));
+    const row = rows?.find((r) => r.min !== undefined || r.max !== undefined);
+    if (!row)
+        return undefined;
+    const range = {};
+    if (typeof row.min === 'number')
+        range.minimum = row.min;
+    if (typeof row.max === 'number')
+        range.maximum = row.max;
+    return Object.keys(range).length ? range : undefined;
+}
+/** Property paths the editor config carries guidance for. Used by tests. */
+export const GUIDED_PATHS = [...rowsByPath.keys()];
+/**
+ * The top-level members the settings panel edits on EVERY element.
+ *
+ * A row named `SpecialElementKeys.Default` is not looked up in an element's
+ * `properties` at all: it is rendered for every element, gated only by its own
+ * `additionalTest` and `disabled` tests. So the members those rows edit are
+ * part of every element's surface in the builder while appearing in no
+ * element's property list — `readonly`, `onlySetTempErrorOnTouch` and
+ * `tourContent` among them. Read here so variant assembly can offer what the
+ * builder offers, from the same source the builder reads.
+ *
+ * Only ungated rows qualify. A gated row is conditional on a VALUE (`min`
+ * needs a numeric `type`; `calculatedFieldRules` needs the flag), which is not
+ * "always shown" and is handled elsewhere. Nested bindings (`script.onChange`,
+ * `matOptions.fetch.value.source`) are members of a nested object, not of the
+ * column, and are left to the modules that own those objects.
+ */
+export const ALWAYS_SHOWN_MEMBERS = [
+    ...new Set(collectRows()
+        .filter((row) => row.name === SpecialElementKeys.Default &&
+        row.deepBind?.length === 1 &&
+        !row.additionalTest?.length &&
+        !row.disabled?.length)
+        .map((row) => row.deepBind[0])),
+];
+/**
+ * Secondary-editor paths, as `openingPath -> propertyPath`. Used by tests to
+ * assert the nested editors are actually being reached: before these were
+ * collected, every hint inside a record-list editor was invisible here, and
+ * nothing failed to say so.
+ */
+export const SECONDARY_GUIDED_PATHS = new Map([...secondaryRowsByParent].map(([parent, inner]) => [
+    parent,
+    [...inner.keys()],
+]));

package/dist/skillet/members/calculated-field.d.ts

@@ -0,0 +1,155 @@
+import { s } from '@hashbrownai/core';
+import type { CalculatedFieldRules } from '../../interfaces/formInput/calculatedFieldRules.js';
+import { CalculationFunctions } from '../../interfaces/formInput/calculationVariableInterface.js';
+/**
+ * The `calculatedFieldRules` member: a value computed from other fields rather
+ * than typed by the user.
+ *
+ * ## Why this is a draft
+ *
+ * `calculationVariableInterface` requires both `id` and `inputId` on every
+ * variable. Those are builder-assigned: `inputId` is the `id` of another input
+ * in the form, stamped when that input was created, and a model has no way to
+ * know it — the form it is authoring does not exist yet, so the ids do not
+ * either. Asked for one it will invent a plausible string, and the formula then
+ * references a field that is not there. The failure is quiet: the form saves,
+ * renders, and computes nothing.
+ *
+ * So the model binds by `formControlName`, which it genuinely does author, and
+ * the application resolves each one to that input's `id` on expansion. Both
+ * names are already on the interface — `formControlName` and
+ * `parentInputFormControl` sit alongside `inputId` and `parentInputId` — so the
+ * draft is not inventing a vocabulary. It fills in the half of each pair a
+ * model can actually know.
+ *
+ * ## The two ways a variable binds
+ *
+ * A variable reads EITHER one field's value directly, OR an aggregate over one
+ * column of a repeatable list. The second needs a set of members the first has
+ * no use for — `function`, `parentInputFormControl`, `applyFunctionToCol` — and
+ * Joi accepts them all on the same flat object, so nothing in the stored shape
+ * says which belong together. Offered flat, a model fills in
+ * `applyFunctionToCol` for a plain field and `function` for something with
+ * nothing to aggregate.
+ *
+ * They are therefore two branches of an `anyOf`, discriminated by an explicit
+ * `bindingType`. That key is NOT a member of `calculationVariableInterface`;
+ * like `endpointId` in `members/mat-options.ts` it exists only in the draft and
+ * is dropped on expansion. It earns the extra expansion step because an
+ * undiscriminated union of two objects sharing three of their keys is exactly
+ * the shape a model picks wrongly.
+ *
+ * The grouping is not invented here: `schemas/customValidationSchema.ts`
+ * annotates the same `parentInputId` + `function` pair as "Multiple-input
+ * (list) bindings", which is the distinction drawn.
+ */
+/** `roundingMode` is a string union with no runtime enum to derive from. */
+export declare const ROUNDING_MODE_VALUES: readonly ["FLOOR", "CEIL", "ROUND"];
+interface VariableCommonDraft {
+    /** The token this variable is referenced by inside `formula`. */
+    variable: string;
+    label: string;
+    formControlName: string;
+}
+export interface FieldVariableDraft extends VariableCommonDraft {
+    bindingType: 'field';
+}
+export interface ListVariableDraft extends VariableCommonDraft {
+    bindingType: 'listAggregate';
+    parentInputFormControl: string;
+    function: CalculationFunctions;
+    applyFunctionToCol: string;
+    applyFunctionToLabel: string | null;
+    filterValuesByCol: string | null;
+    filterValuesByThisColLabel: string | null;
+    tableCell: boolean | null;
+}
+export type CalculationVariableDraft = FieldVariableDraft | ListVariableDraft;
+export interface CalculatedFieldRulesDraft {
+    formula: string;
+    variables: CalculationVariableDraft[];
+    decimalPlaces: number | null;
+    roundingMode: (typeof ROUNDING_MODE_VALUES)[number] | null;
+    getFormulaFromAFormInput: boolean | null;
+    formControlWithFormula: string | null;
+}
+export declare const calculationVariableDraftSchema: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
+    bindingType: "field";
+    variable: string;
+    label: string;
+    formControlName: string;
+} | {
+    bindingType: "listAggregate";
+    variable: string;
+    label: string;
+    formControlName: string;
+    parentInputFormControl: string;
+    function: CalculationFunctions;
+    applyFunctionToCol: string;
+    applyFunctionToLabel: string | null;
+    filterValuesByCol: string | null;
+    filterValuesByThisColLabel: string | null;
+    tableCell: boolean | null;
+}>;
+/**
+ * The editor's applicability text for this row is deliberately NOT composed in.
+ *
+ * `describe(..., 'calculatedFieldRules')` resolves to "Only applies when
+ * isCalculatedField is true", which is correct in the settings panel and
+ * incoherent here: `variants.ts` encodes that rule as the shape of the union
+ * and drops `isCalculatedField` from the schema entirely, so the sentence would
+ * point a model at a member it is never shown — an invitation to invent one.
+ *
+ * This is the same judgement `internal/editor-guidance.ts` records for `label`
+ * and `options`: derived text earns its place by telling a model something it
+ * does not already have, and a rule the structure already makes unbreakable is
+ * not that.
+ */
+export declare const calculatedFieldRulesDraftSchema: s.ObjectType<{
+    formula: s.StringType;
+    variables: s.ArrayType<import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
+        bindingType: "field";
+        variable: string;
+        label: string;
+        formControlName: string;
+    } | {
+        bindingType: "listAggregate";
+        variable: string;
+        label: string;
+        formControlName: string;
+        parentInputFormControl: string;
+        function: CalculationFunctions;
+        applyFunctionToCol: string;
+        applyFunctionToLabel: string | null;
+        filterValuesByCol: string | null;
+        filterValuesByThisColLabel: string | null;
+        tableCell: boolean | null;
+    }>>;
+    decimalPlaces: import("@hashbrownai/core/src/schema/base").SchemaForUnion<number | null>;
+    roundingMode: import("@hashbrownai/core/src/schema/base").SchemaForUnion<"FLOOR" | "CEIL" | "ROUND" | null>;
+    getFormulaFromAFormInput: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
+    formControlWithFormula: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+}>;
+/**
+ * The draft is checked against its declared shape, not against
+ * `CalculatedFieldRules`: it deliberately differs, carrying `bindingType` and
+ * omitting the two identifiers the application supplies. What the compiler can
+ * still hold is that the node produces the draft it claims to.
+ */
+export type _NoCalculatedFieldDraftDrift = [
+    s.Infer<typeof calculatedFieldRulesDraftSchema>
+] extends [CalculatedFieldRulesDraft] ? never : ['calculatedFieldRulesDraftSchema drifted from CalculatedFieldRulesDraft'];
+/**
+ * The parts of the draft stored verbatim stay pinned to the real interface, so
+ * retyping `roundingMode` upstream surfaces here rather than in a form that
+ * silently rounds the wrong way.
+ */
+export type _RoundingModeMatchesInterface = [
+    (typeof ROUNDING_MODE_VALUES)[number]
+] extends [NonNullable<CalculatedFieldRules['roundingMode']>] ? never : ['ROUNDING_MODE_VALUES drifted from CalculatedFieldRules'];
+/**
+ * Members of a generated `calculatedFieldRules` the application must supply
+ * before Joi will accept it.
+ */
+export declare const CALCULATED_FIELD_DRAFT_COMPLETION: readonly ["calculatedFieldRules.variables[].id", "calculatedFieldRules.variables[].inputId (resolved from formControlName)", "calculatedFieldRules.variables[].parentInputId (resolved from parentInputFormControl)", "calculatedFieldRules.variables[].bindingType (draft-only; dropped on expansion)"];
+export {};