ngx-t-forms-types 0.0.30 → 0.0.33

package/dist/skillet/input-members.js

@@ -0,0 +1,186 @@
+import { s } from '@hashbrownai/core';
+import { AllFormInputPrimaryKeys } from '../interfaces/FormBuilder/FormInputKeys.js';
+import { matOptionsSchema } from './members/mat-options.js';
+import { calculatedFieldRulesDraftSchema, } from './members/calculated-field.js';
+import { validatorsDraftSchema, } from './members/validators.js';
+import { conditionalInputConfigDraftSchema, } from './members/conditional.js';
+import { mscoaConfigSchema } from './members/mscoa.js';
+import { paginationSelectionConfigDraftSchema, } from './members/pagination.js';
+import { calculateListFunctionsSchema, scriptSchema, valueSchema, } from './members/value.js';
+import { enumValues } from './internal/coupling.js';
+import { CONTROL_NAME_PATTERN } from './authoring-rules.js';
+import { describe, rangeFor } from './internal/editor-guidance.js';
+import { adjudicationStepSchema, appearanceSchema, autocapitalizeSchema, elementTypeSchema, inputDataTypeSchema, inputFileTypeSchema, inputPipeTypeSchema, inputTypeSchema, inputViewTypeSchema, labelPositionSchema, optionSelectTypeSchema, richTextEditorTypeSchema, textareaWrapSchema, } from './shared-types.js';
+/**
+ * Members a model must never author: identifiers the builder assigns and
+ * runtime state the form owns while it is open. These are excluded from
+ * generation schemas entirely and stitched in afterwards.
+ */
+export const SYSTEM_OWNED_INPUT_MEMBERS = [
+    AllFormInputPrimaryKeys.Id,
+    AllFormInputPrimaryKeys.SectionId,
+    AllFormInputPrimaryKeys.SystemDefault,
+    AllFormInputPrimaryKeys.Status,
+    AllFormInputPrimaryKeys.ValueUpdatedAt,
+    AllFormInputPrimaryKeys.TemporaryHint,
+    AllFormInputPrimaryKeys.FormIsOpen,
+    AllFormInputPrimaryKeys.MultipleInputInEditId,
+    AllFormInputPrimaryKeys.CanReload,
+];
+/**
+ * Members kept only so stored forms keep deserialising. They are excluded from
+ * generation entirely: a model must never author a property the codebase has
+ * already moved on from, and leaving one in the schema would see it reappear on
+ * every newly generated input.
+ */
+export const DEPRECATED_INPUT_MEMBERS = [
+    AllFormInputPrimaryKeys.IServeInputWithRequisitionItems,
+];
+/**
+ * Members whose shape is a nested configuration object deserving its own
+ * module. Listed rather than stubbed: a placeholder node would compile and then
+ * quietly feed the model a wrong shape, which is worse than an absent one.
+ */
+export const PENDING_INPUT_MEMBERS = [
+    AllFormInputPrimaryKeys.AdjudicationReviewFeedbackTemplate,
+];
+/**
+ * Members whose node cannot be built until assembly, because its shape depends
+ * on something only the caller knows.
+ *
+ * These differ from {@link DRAFT_INPUT_MEMBERS} in that there is no sensible
+ * default node to publish at all:
+ *
+ * - `workflowPickerConfig` needs the workflows available in the caller's
+ *   context. With none, the member is not offered — the same reasoning that
+ *   withholds the `api` source in `members/mat-options.ts`, and for the same
+ *   reason: a fabricated `workflowId` produces a picker that looks right and
+ *   points at nothing.
+ * - `formInputs` is the contents of a repeatable list, which is itself a list
+ *   of columns. It can only be built once the remaining nesting depth is known,
+ *   because Skillet has no way to express a recursive schema and the recursion
+ *   has to be unrolled to a fixed depth instead.
+ *
+ * `variants.ts` resolves both while it walks an element's properties.
+ */
+export const ASSEMBLED_INPUT_MEMBERS = [
+    AllFormInputPrimaryKeys.WorkflowPickerConfig,
+    AllFormInputPrimaryKeys.FormInputs,
+];
+/**
+ * Members whose schema produces an AUTHORING DRAFT rather than the stored
+ * shape, because some part of the stored shape is not knowable from a prompt.
+ *
+ * `matOptions` is the first of these: an api source is stored as a full
+ * endpoint configuration — `_id`, `httpEndPoint`, `httpMethod`, headers — and a
+ * model asked for that invents a URL. So the draft carries the id of an
+ * endpoint the caller supplied, and the application expands it before the form
+ * is validated.
+ *
+ * These are checked against their declared draft type rather than against the
+ * interface member, so the compiler still holds them to something. What it
+ * cannot check is the expansion itself; that contract lives with the caller.
+ */
+export const DRAFT_INPUT_MEMBERS = [
+    AllFormInputPrimaryKeys.MatOptions,
+    AllFormInputPrimaryKeys.CalculatedFieldRules,
+    AllFormInputPrimaryKeys.Validators,
+    AllFormInputPrimaryKeys.ConditionalInputConfig,
+    AllFormInputPrimaryKeys.MscoaConfig,
+    AllFormInputPrimaryKeys.PaginationSelectionConfig,
+    AllFormInputPrimaryKeys.CalculateListFunctions,
+];
+/**
+ * Members whose model output must be expanded before it satisfies the
+ * interfaces. Kept apart from {@link inputMemberSchemas} so that consuming code
+ * cannot treat a draft as a finished value by accident.
+ */
+export const draftMemberSchemas = {
+    [AllFormInputPrimaryKeys.MatOptions]: matOptionsSchema,
+    [AllFormInputPrimaryKeys.CalculatedFieldRules]: calculatedFieldRulesDraftSchema,
+    [AllFormInputPrimaryKeys.Validators]: validatorsDraftSchema,
+    [AllFormInputPrimaryKeys.ConditionalInputConfig]: conditionalInputConfigDraftSchema,
+    [AllFormInputPrimaryKeys.MscoaConfig]: mscoaConfigSchema,
+    [AllFormInputPrimaryKeys.PaginationSelectionConfig]: paginationSelectionConfigDraftSchema,
+    [AllFormInputPrimaryKeys.CalculateListFunctions]: calculateListFunctionsSchema,
+};
+// Descriptions on the members every element shares are kept SHORT on purpose:
+// each is repeated once per element per nesting level in the emitted schema,
+// because Hashbrown names `$defs` entries by their description. The
+// definition and the one rule that belongs at the member stay here; the
+// form-wide rules live in `authoring-rules.ts`, emitted once at the root.
+export const inputMemberSchemas = {
+    // --- identity and layout --------------------------------------------------
+    [AllFormInputPrimaryKeys.Element]: elementTypeSchema,
+    [AllFormInputPrimaryKeys.Label]: s.string(describe("The visible field label: a noun phrase of one to three words in sentence case, in the words of the people who fill the form in ('Cost centre', not 'cc_code'), with no colon or trailing punctuation. It is also the heading the answer is printed under, so it must make sense on its own.", AllFormInputPrimaryKeys.Label)),
+    [AllFormInputPrimaryKeys.FormControlName]: s.string(describe("The key this value is stored under, derived from the label so that it identifies the field on its own: 'budgetReview', not 'toggle1'. Unique across the whole form; never a reserved name; never changed once the form is live.", AllFormInputPrimaryKeys.FormControlName), { pattern: CONTROL_NAME_PATTERN }),
+    [AllFormInputPrimaryKeys.ColSize]: s.integer(describe('How many of the 12 grid columns this control spans. Size it to the data: 12 for long text, a textarea, an item list, a picker, an uploader or a signature; 6, 4 or 3 for a date, an amount, a quantity, a short code or a toggle.', AllFormInputPrimaryKeys.ColSize), rangeFor(AllFormInputPrimaryKeys.ColSize) ?? { minimum: 1, maximum: 12 }),
+    [AllFormInputPrimaryKeys.Appearance]: appearanceSchema,
+    [AllFormInputPrimaryKeys.DataType]: inputDataTypeSchema,
+    [AllFormInputPrimaryKeys.Type]: inputTypeSchema,
+    [AllFormInputPrimaryKeys.ViewType]: inputViewTypeSchema,
+    // --- obligation and state -------------------------------------------------
+    [AllFormInputPrimaryKeys.Required]: s.boolean(describe('Whether the user must supply a value before the form can be submitted. Required when the next step cannot proceed without it; if in doubt, not required; if required only sometimes, use a validator or a conditional display rule instead.', AllFormInputPrimaryKeys.Required)),
+    [AllFormInputPrimaryKeys.Readonly]: s.boolean(describe("Whether the value is displayed but cannot be edited: for an earlier step's answer, a profile value, a fetched figure. The value is still submitted.", AllFormInputPrimaryKeys.Readonly)),
+    [AllFormInputPrimaryKeys.ShowAsLabel]: s.boolean(describe('Renders the value as plain text instead of a form control.', AllFormInputPrimaryKeys.ShowAsLabel)),
+    [AllFormInputPrimaryKeys.OnlySetTempErrorOnTouch]: s.boolean(describe('Withholds validation errors until the user has interacted with the field. True on nearly every field.', AllFormInputPrimaryKeys.OnlySetTempErrorOnTouch)),
+    [AllFormInputPrimaryKeys.IsCalculatedField]: s.boolean(describe('Whether this value is computed from other fields rather than entered by the user.', AllFormInputPrimaryKeys.IsCalculatedField)),
+    // --- guidance -------------------------------------------------------------
+    [AllFormInputPrimaryKeys.HintLabel]: s.string(describe('Short helper text shown under the field permanently: one sentence with no full stop, giving the format, the source, or the reason for asking. On a sectionTitle it is the guidance for the whole group that follows and may run to two sentences.', AllFormInputPrimaryKeys.HintLabel)),
+    [AllFormInputPrimaryKeys.TourContent]: s.string(describe('Guided-tour copy shown when the form is first walked through. Only for a genuinely unfamiliar control such as an account picker or a document picker: two sentences, what it is and what to do.', AllFormInputPrimaryKeys.TourContent)),
+    // --- text behaviour -------------------------------------------------------
+    [AllFormInputPrimaryKeys.Spellcheck]: s.boolean(describe('Whether the browser spell-checks the typed text. Enable for prose, disable for codes and identifiers.', AllFormInputPrimaryKeys.Spellcheck)),
+    [AllFormInputPrimaryKeys.Autocapitalize]: autocapitalizeSchema,
+    [AllFormInputPrimaryKeys.Rows]: s.integer(describe('Visible height of a textarea, in lines.', AllFormInputPrimaryKeys.Rows), { minimum: 1 }),
+    [AllFormInputPrimaryKeys.Wrap]: textareaWrapSchema,
+    [AllFormInputPrimaryKeys.RichTextEditorLibrary]: richTextEditorTypeSchema,
+    // --- constraints ----------------------------------------------------------
+    // A union node has no description slot of its own, so the applicability rule
+    // the editor declares for these — they mean nothing unless the input is
+    // numeric or a date — is composed onto each branch instead. Dropping it would
+    // lose the single most useful thing the editor config knows about them.
+    [AllFormInputPrimaryKeys.Min]: s.anyOf([
+        s.number(describe('A numeric lower bound: 1 for a quantity, 0 for an amount or a percentage.', AllFormInputPrimaryKeys.Min)),
+        s.string(describe('A lower bound as an ISO date, for date controls.', AllFormInputPrimaryKeys.Min)),
+    ]),
+    [AllFormInputPrimaryKeys.Max]: s.anyOf([
+        s.number(describe('A numeric upper bound: 100 for a percentage.', AllFormInputPrimaryKeys.Max)),
+        s.string(describe('An upper bound as an ISO date, for date controls.', AllFormInputPrimaryKeys.Max)),
+    ]),
+    [AllFormInputPrimaryKeys.MinLength]: s.integer(describe('The fewest characters the value may contain.', AllFormInputPrimaryKeys.MinLength), { minimum: 0 }),
+    [AllFormInputPrimaryKeys.MaxLength]: s.integer(describe('The most characters the value may contain. Match the limit of the system the value is stored in, and say so in the hint when it matters.', AllFormInputPrimaryKeys.MaxLength), { minimum: 1 }),
+    // --- options and selection ------------------------------------------------
+    [AllFormInputPrimaryKeys.OptionSelectType]: optionSelectTypeSchema,
+    [AllFormInputPrimaryKeys.AllowMultipleSelection]: s.boolean(describe('Whether more than one option may be chosen at once.', AllFormInputPrimaryKeys.AllowMultipleSelection)),
+    [AllFormInputPrimaryKeys.SingleSelect]: s.boolean(describe('Restricts the control to exactly one selection.', AllFormInputPrimaryKeys.SingleSelect)),
+    [AllFormInputPrimaryKeys.GroupBy]: s.array(describe('Option properties to group the list under, outermost first. Leave empty for a flat list.', AllFormInputPrimaryKeys.GroupBy), s.string('An option property name to group by.')),
+    // --- toggle ---------------------------------------------------------------
+    [AllFormInputPrimaryKeys.LabelPosition]: labelPositionSchema,
+    [AllFormInputPrimaryKeys.TrueLabel]: s.string(describe("Text shown when a toggle is on. Name the real state — 'Approve', 'VAT registered' — never a bare 'Yes', which forces the user to re-read the label.", AllFormInputPrimaryKeys.TrueLabel)),
+    [AllFormInputPrimaryKeys.FalseLabel]: s.string(describe("Text shown when a toggle is off: the direct opposite of the true label — 'Reject', 'Not VAT registered' — never a bare 'No'.", AllFormInputPrimaryKeys.FalseLabel)),
+    // --- dates ----------------------------------------------------------------
+    [AllFormInputPrimaryKeys.StartDateControl]: s.string(describe('The formControlName holding the start of a date range. A range stores two values, so both this and endDateControl must be set, or the field is dropped from prefill, export and print.', AllFormInputPrimaryKeys.StartDateControl)),
+    [AllFormInputPrimaryKeys.EndDateControl]: s.string(describe('The formControlName holding the end of a date range. Both this and startDateControl must be set.', AllFormInputPrimaryKeys.EndDateControl)),
+    // --- files ----------------------------------------------------------------
+    [AllFormInputPrimaryKeys.FileType]: inputFileTypeSchema,
+    [AllFormInputPrimaryKeys.Accept]: s.string(describe('Accepted upload types as an HTML accept attribute, for example ".pdf,.docx" or "image/*". Match it to the documents actually expected, and name the accepted types in the hint as well.', AllFormInputPrimaryKeys.Accept)),
+    [AllFormInputPrimaryKeys.HandleLabel]: s.string(describe("The text of the button that adds a row to an item list. Name the action — 'Add item', 'Add attendee' — not the default 'Add to list'.", AllFormInputPrimaryKeys.HandleLabel)),
+    // --- display transform ----------------------------------------------------
+    [AllFormInputPrimaryKeys.Pipe]: s.object(describe('A display transform applied when the value is shown back to the user: currency for an amount, percent for a rate, date for a date. Presentation only; the stored value is unchanged.', AllFormInputPrimaryKeys.Pipe), {
+        pipeType: inputPipeTypeSchema,
+        param: s.string('The pipe argument, such as a date format like "dd MMM yyyy" or a currency code like "ZAR".'),
+    }),
+    // --- domain ---------------------------------------------------------------
+    [AllFormInputPrimaryKeys.LinkedSegmentId]: s.string(describe('Identifier of the mSCOA segment this control resolves against.', AllFormInputPrimaryKeys.LinkedSegmentId)),
+    [AllFormInputPrimaryKeys.AdjudicationStep]: adjudicationStepSchema,
+    [AllFormInputPrimaryKeys.AdjudicationPointTypes]: s.array(describe('The scoring categories available at this adjudication step.', AllFormInputPrimaryKeys.AdjudicationPointTypes), s.string('A scoring category name.')),
+    [AllFormInputPrimaryKeys.WorkflowFormForScoreSheet]: s.string(describe('Identifier of the form supplying the score sheet for this adjudication.', AllFormInputPrimaryKeys.WorkflowFormForScoreSheet)),
+    // --- prefilled value and behaviour ---------------------------------------
+    // Both are modelled rather than drafted: they carry no builder-assigned
+    // identifier, so what the model emits is what gets stored. See
+    // `members/value.ts` for the narrowing each one applies.
+    [AllFormInputPrimaryKeys.Value]: valueSchema,
+    [AllFormInputPrimaryKeys.Script]: scriptSchema,
+};
+/** Runtime access to the full key list, derived from the enum. */
+export const ALL_INPUT_MEMBER_KEYS = enumValues(AllFormInputPrimaryKeys);

package/dist/skillet/internal/coupling.d.ts

@@ -0,0 +1,63 @@
+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 declare function matches<Expected>(): <Node extends s.HashbrownType>(node: [s.Infer<Node>] extends [Expected] ? Node : never) => 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 declare function enumValues<E extends Record<string, string>>(enumObject: E): E[keyof E][];
+/**
+ * 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 declare function exhaustive<Union extends string>(): <Tuple extends readonly Union[]>(entries: [Exclude<Union, Tuple[number]>] extends [never] ? Tuple : never) => Tuple;
+/**
+ * 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 declare function optional<Node extends s.HashbrownType>(node: Node): import("@hashbrownai/core/src/schema/base").SchemaForUnion<(Node | s.NullType)["~schema"]["result"]>;
+/** Resolves to `never` unless `T` is `never`; used to prove a set is empty. */
+export type AssertNever<T extends never> = T;

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[]>;