ngx-t-forms-types 0.0.30 → 0.0.34

package/dist/interfaces/formInput/APIDataFetchingConfigurationInterface.d.ts

@@ -199,6 +199,40 @@ export interface APIDataFetchingConfigurationInterface extends DataFetchingBaseC
      * interpreted — mirrors the other `captured*` seeds.
      */
     capturedDocs?: string;
+    /**
+     * Opts this value out of the automatic read-only lock, so a user may supply
+     * what the tower's own value leaves out.
+     *
+     * An input whose value the tower owns is rendered read-only by default — a
+     * typed-over value would only be overwritten on the derived signal's next
+     * evaluation. This flag lifts that lock, and what it then means depends on
+     * the SHAPE the input declares in its `dataType`:
+     *
+     * **Scalar** (`string`, `number`, `boolean`, `date`, …) — the editor's *Allow
+     * manual entry when the API returns nothing* toggle, offered only on an `api`
+     * value source. The manually entered value stands **whenever the fetch
+     * contributes nothing** — no response yet, a `null` / empty response, or a
+     * failed request. A non-empty response always wins. A scalar that is
+     * calculated (`calculatedFieldRules`) or inherited from another input
+     * (`source: 'local'`) is read-only unconditionally and ignores this flag,
+     * because its derived signal recomputes synchronously from inputs the user
+     * can already edit.
+     *
+     * **Complex** (`dataType: 'object' | 'array'` — mSCOA, MultipleInput) — the
+     * editor's *Allow the user to complete this value* toggle, offered on a
+     * `local` value source as well as an `api` one. A multi-dimensional value can
+     * arrive partially populated (an mSCOA that inherits two of its segments,
+     * rows that come back missing a column), so the field stays editable and the
+     * tower **re-merges** rather than replacing: every change in the derived value
+     * is applied over the live value as a delta — what the tower supplies updates,
+     * what the user added survives. The first value the tower produces is taken
+     * whole; there is no earlier value to diff it against.
+     *
+     * Absent / `false` ⇒ the historical behaviour: the field is locked.
+     *
+     * @defaultValue false
+     */
+    allowManualValueEntry?: boolean;
     backEndConfig: {
         /**
          * The default/mapTo mapping that shapes the POST body in `'mappedInputs'` mode.

package/dist/interfaces/formInput/BasicFormInputInterface.d.ts

@@ -24,6 +24,7 @@ export declare enum ElementTypes {
     IconSelect = "iconSelect",
     Textarea = "textarea",
     DatePicker = "datePicker",
+    DateTimePicker = "dateTimePicker",
     DateRangePicker = "dateRangePicker",
     FileUpload = "fileUpload",
     Signature = "signature",

package/dist/interfaces/formInput/BasicFormInputInterface.js

@@ -8,6 +8,7 @@ export var ElementTypes;
     ElementTypes["IconSelect"] = "iconSelect";
     ElementTypes["Textarea"] = "textarea";
     ElementTypes["DatePicker"] = "datePicker";
+    ElementTypes["DateTimePicker"] = "dateTimePicker";
     ElementTypes["DateRangePicker"] = "dateRangePicker";
     ElementTypes["FileUpload"] = "fileUpload";
     ElementTypes["Signature"] = "signature";

package/dist/interfaces/formInput/IMscoaAccount.d.ts

@@ -133,9 +133,11 @@ export type DualCashExclusionMatchMode = 'any' | 'all';
  * one selected accrual account value in its segment scope.
  *
  * The pattern is tested against the account's `SCOAAccount` value AND the value
- * of the field named by {@link IScoaInputConfig.accountValueLabel} (what the
- * user sees selected in the chart). An invalid pattern never matches — it can
- * therefore never suppress the cash requirement by accident.
+ * of ONE labelled field: by default the field named by
+ * {@link IScoaInputConfig.accountValueLabel} (what the user sees selected in the
+ * chart), or — when the rule sets one — the field named by
+ * {@link IDualCashExclusionRule.matchField}. An invalid pattern never matches, so
+ * it can never suppress the cash requirement by accident.
  */
 export interface IDualCashExclusionRule {
     /** Stable record id (stamped by the builder's record-list editor). */
@@ -144,6 +146,20 @@ export interface IDualCashExclusionRule {
     pattern: string;
     /** Optional regex flags (e.g. `i`). Invalid flags make the rule evaluate as not matched. */
     flags?: string;
+    /**
+     * Optional per-rule override of WHICH labelled account field the pattern is
+     * tested against, named exactly as the account carries it — the same pool the
+     * `accountValueLabel` picker offers (e.g. `ShortDescription`).
+     *
+     * Empty or absent means the input's configured
+     * {@link IScoaInputConfig.accountValueLabel}, which is the default and leaves
+     * every rule saved before this member existed evaluating exactly as it did.
+     * The account's `SCOAAccount` value is always tested as well, whatever this
+     * holds — the override replaces the labelled field only. A field the selected
+     * account does not carry contributes no candidate, so such a rule falls back to
+     * testing `SCOAAccount` alone rather than matching everything.
+     */
+    matchField?: string;
     /**
      * Optional segment scope (matched case-insensitively against the accrual
      * segment key, e.g. `ITEM`). Empty/absent = every accrual segment.

package/dist/interfaces/formInput/ISelectInputInterface.d.ts

@@ -4,9 +4,21 @@ import { IBasicFormInput, OptionSelectTypes } from "./BasicFormInputInterface.js
 export interface ISelectInputInterface extends IBasicFormInput {
     [AllFormInputPrimaryKeys.OptionSelectType]: OptionSelectTypes;
     [AllFormInputPrimaryKeys.AllowMultipleSelection]: boolean;
+    /**
+     * The most options a user may choose at once.
+     *
+     * Only meaningful alongside {@link ISelectInputInterface.allowMultipleSelection};
+     * a single-selection control is already capped at one. Declared on each
+     * multi-select interface rather than on `IBasicFormInput`, the same way
+     * `allowMultipleSelection` itself is, so a control that cannot select
+     * several things does not appear to offer a limit on how many.
+     */
+    selectUpto?: number;
 }
 export interface IPaginatedSelectionTableInputInterface extends IBasicFormInput {
     [AllFormInputPrimaryKeys.AllowMultipleSelection]: boolean;
+    /** @see ISelectInputInterface.selectUpto */
+    selectUpto?: number;
     [AllFormInputPrimaryKeys.PaginationSelectionConfig]: {
         useLocalPagination: boolean;
         primaryIdentifierKey?: TreeNode[];

package/dist/interfaces/formInput/MultipleInterface.d.ts

@@ -15,6 +15,16 @@ export interface IMultiple extends IBasicFormInput {
     multipleInputAvailableOperations?: Array<MultipleInputAvailableOperations>;
     calculateListFunctions: Array<IMultipleInputCal>;
     groupBy?: string[];
+    /**
+     * The `formControlName`s of columns inside this group whose values are
+     * summed and shown as a total beneath the rows.
+     *
+     * Belongs here rather than on `IBasicFormInput` because a total only means
+     * something over a set of rows: each name must be a field declared in
+     * {@link IMultiple.formInputs}. The legacy `init-form` shape grouped it with
+     * `formInputs` and `groupBy` for the same reason.
+     */
+    showTotalsOf?: string[];
 }
 export interface IMultipleInputCal {
     id: string;

package/dist/interfaces/formInput/WorkflowDocumentPicker.d.ts

@@ -5,6 +5,8 @@ import { IBasicFormInput } from "./BasicFormInputInterface.js";
 export interface IWorkflowDocumentPicker extends IBasicFormInput {
     workflowPickerConfig: IWorkflowDocumentPickerConfig;
     [AllFormInputPrimaryKeys.AllowMultipleSelection]: boolean;
+    /** @see ISelectInputInterface.selectUpto */
+    selectUpto?: number;
 }
 /**
  * Document-picker configuration.

package/dist/schemas/FormInputSchema.js

@@ -1,6 +1,6 @@
 import Joi from 'joi';
-import { AllFormInputPrimaryKeys, SpecialElementKeys } from '../interfaces/FormBuilder/index.js';
-import { AdjudicationSteps, AutocapitalizeOptions, ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from '../interfaces/formInput/index.js';
+import { AllFormInputPrimaryKeys, FormInputKeys, SpecialElementKeys } from '../interfaces/FormBuilder/index.js';
+import { AdjudicationSteps, AutocapitalizeOptions, AutocompleteOptions, ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from '../interfaces/formInput/index.js';
 // import { InputFileType } from '../interfaces/formInput/FileUploadInputInterface.js';
 // import { LabelPosition } from '../interfaces/formInput/ToggleInputInterface.js';
 // import { MscoaInputConfigSchema } from './MscoaConfigSchema.js';
@@ -49,6 +49,45 @@ export const baseFormColumnInputsSchema = Joi.object({
     [AllFormInputPrimaryKeys.Max]: Joi.alternatives().try(Joi.number(), Joi.string(), Joi.date()).optional(),
     [AllFormInputPrimaryKeys.MinLength]: Joi.alternatives().try(Joi.number(), Joi.string()).optional(),
     [AllFormInputPrimaryKeys.MaxLength]: Joi.alternatives().try(Joi.number(), Joi.string()).optional(),
+    [FormInputKeys.Pattern]: Joi.string().allow('').optional(),
+    // --- presentation members declared on IBasicFormInput ----------------------
+    //
+    // These were declared on the interfaces and listed in DefaultInputConfig, but
+    // never here — and because Joi rejects unknown keys, a column carrying one
+    // failed the WHOLE form with '"Slides > Columns > Placeholder" is not
+    // allowed'. Empty strings are allowed throughout: the settings panel writes
+    // '' when an author clears a text row, and rejecting that made clearing a
+    // prefix a validation error.
+    [FormInputKeys.Placeholder]: Joi.string().allow('').optional(),
+    [FormInputKeys.Autocomplete]: Joi.string().valid(...Object.values(AutocompleteOptions)).optional(),
+    [FormInputKeys.Disabled]: Joi.boolean().optional(),
+    [FormInputKeys.PrefixText]: Joi.string().allow('').optional(),
+    [FormInputKeys.SuffixText]: Joi.string().allow('').optional(),
+    [FormInputKeys.PrefixIcon]: Joi.string().allow('').optional(),
+    [FormInputKeys.SuffixIcon]: Joi.string().allow('').optional(),
+    // Only meaningful alongside allowMultipleSelection; a single-selection
+    // control is already capped at one. `min(1)` because "select up to zero" is
+    // not a limit, it is a disabled control.
+    [FormInputKeys.SelectUpto]: Joi.number().integer().min(1).optional(),
+    // formControlNames of columns inside a multipleInput group to total.
+    [FormInputKeys.ShowTotalsOf]: Joi.array().items(Joi.string()).optional(),
+    // --- matrix table ---------------------------------------------------------
+    //
+    // Declared by IMatrixInput and accepted here so a stored form carrying either
+    // still validates. No element offers them: ElementTypes.MatrixTable is
+    // commented out of the enum, so nothing can currently be built with one.
+    //
+    // `columnsConfig` is keyed by column name and typed
+    // `TableColumnConfigInterface | any`, so its values are only checked to be
+    // objects — constraining them further here would reject the `any` half the
+    // interface explicitly permits.
+    [FormInputKeys.MatrixTableConfig]: Joi.object({
+        dataSource: Joi.string().required()
+    }).optional(),
+    [FormInputKeys.TableConfig]: Joi.object({
+        displayedColumnsInOrder: Joi.array().items(Joi.string()).required(),
+        columnsConfig: Joi.object().pattern(Joi.string(), Joi.object()).required()
+    }).optional(),
     [AllFormInputPrimaryKeys.LinkedSegmentId]: Joi.string().optional(),
     [AllFormInputPrimaryKeys.MscoaConfig]: MscoaInputConfigSchema.optional(),
     [AllFormInputPrimaryKeys.SystemDefault]: Joi.boolean().optional(),

package/dist/schemas/MatOptionsSchema.js

@@ -59,6 +59,13 @@ const APIDataFetchingConfigurationSchema = Joi.object({
     capturedQuery: queryTemplateSchema.optional(),
     // The endpoint's Postman description, verbatim; display-only (Docs tab).
     capturedDocs: Joi.string().allow('').optional(),
+    // Opt-out of the automatic read-only lock on a value the tower owns. On a
+    // SCALAR it is gap-filling on an 'api' slot: a manually entered value stands
+    // whenever the fetch contributes nothing. On a COMPLEX value (the input
+    // declares dataType 'object' or 'array') it is also offered on a 'local'
+    // slot, and the tower re-merges each new derived value over the live one as a
+    // delta instead of replacing it. Only meaningful on a value slot.
+    allowManualValueEntry: Joi.boolean().optional(),
     backEndConfig: Joi.object({
         // Optional: a 'template'-mode fetch shapes its body from payloadTemplate and
         // carries no mapping; GET fetches never had one. Readers default it to [].

package/dist/schemas/MscoaConfigSchema.js

@@ -16,6 +16,7 @@ export const DualCashExclusionRuleSchema = Joi.object({
     id: Joi.string().optional(),
     pattern: Joi.string().required(),
     flags: Joi.string().allow('').optional(),
+    matchField: Joi.string().allow('').optional(),
     segment: Joi.string().allow('').optional(),
     description: Joi.string().allow('').optional()
 });

package/dist/schemas/index.d.ts

@@ -1,4 +1,5 @@
 import { validateCalculatedFieldRules } from "./CalculatedFieldRulesSchema.js";
 import { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired } from "./FormInputSchema.js";
 import { DatabaseFormSchema, FormSchema, validateApiDataFetchingConfiguration, validateForm, validateFormSlide } from "./FormSchema.js";
-export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration };
+import { MscoaInputConfigSchema, validateMscoaInputConfig } from "./MscoaConfigSchema.js";
+export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration, MscoaInputConfigSchema, validateMscoaInputConfig };

package/dist/schemas/index.js

@@ -1,4 +1,5 @@
 import { validateCalculatedFieldRules } from "./CalculatedFieldRulesSchema.js";
 import { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired } from "./FormInputSchema.js";
 import { DatabaseFormSchema, FormSchema, validateApiDataFetchingConfiguration, validateForm, validateFormSlide } from "./FormSchema.js";
-export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration };
+import { MscoaInputConfigSchema, validateMscoaInputConfig } from "./MscoaConfigSchema.js";
+export { FormSchema, DatabaseFormSchema, formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration, MscoaInputConfigSchema, validateMscoaInputConfig };

package/dist/skillet/authoring-rules.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Form-wide authoring rules from the Form Creation Guide, stated once.
+ *
+ * ## Why these are not on the members they concern
+ *
+ * Hashbrown names every hoisted `$defs` entry by camel-casing the node's
+ * DESCRIPTION, and every `$ref` repeats that name in full. A member shared by
+ * every element — `label`, `formControlName`, `colSize` — is referenced once
+ * per element per nesting level, so each character of its description is paid
+ * around forty times in the full column schema. Measured before this split,
+ * `$ref` names were 58% of the full schema and 44% of the common one, and the
+ * seven most-shared members accounted for most of that.
+ *
+ * So a shared member's description carries its definition and the one rule
+ * that has to be read at that member, and the guidance that applies across the
+ * form is stated here, on the root, which is emitted exactly once. The
+ * sentences are the guide's — see `doc/features/skillet-internals.md`, "Where
+ * the prose comes from" — and they are the ones a model needs before it writes
+ * any field rather than while it writes one.
+ *
+ * `createFormDraftSchema()` composes these into the form's description. A
+ * caller using `createColumnSchema()` on its own has no root to carry them and
+ * should put {@link describeAuthoringRules} in the system prompt instead.
+ */
+/**
+ * The shape of a control name: lowerCamelCase, letters and digits only.
+ *
+ * Narrower than the engine, which also allows underscores — narrower is the
+ * permitted direction, and one convention is easier to follow than two.
+ * Exported so a test can hold the reserved-names rule to it: a reserved name
+ * the pattern would accept must be named in the rules, and one it rejects
+ * need not be.
+ */
+export declare const CONTROL_NAME_PATTERN = "^[a-z][a-zA-Z0-9]*$";
+/**
+ * The rules, one sentence group each, in the order the guide states them:
+ * naming, words, types, what the engine reads, layout, error timing.
+ */
+export declare const AUTHORING_RULES: readonly string[];
+/** The rules as one paragraph, for a form description or a system prompt. */
+export declare function describeAuthoringRules(): string;

package/dist/skillet/authoring-rules.js

@@ -0,0 +1,61 @@
+import { RESERVED_CONTROL_NAMES } from './workflow-context.js';
+/**
+ * Form-wide authoring rules from the Form Creation Guide, stated once.
+ *
+ * ## Why these are not on the members they concern
+ *
+ * Hashbrown names every hoisted `$defs` entry by camel-casing the node's
+ * DESCRIPTION, and every `$ref` repeats that name in full. A member shared by
+ * every element — `label`, `formControlName`, `colSize` — is referenced once
+ * per element per nesting level, so each character of its description is paid
+ * around forty times in the full column schema. Measured before this split,
+ * `$ref` names were 58% of the full schema and 44% of the common one, and the
+ * seven most-shared members accounted for most of that.
+ *
+ * So a shared member's description carries its definition and the one rule
+ * that has to be read at that member, and the guidance that applies across the
+ * form is stated here, on the root, which is emitted exactly once. The
+ * sentences are the guide's — see `doc/features/skillet-internals.md`, "Where
+ * the prose comes from" — and they are the ones a model needs before it writes
+ * any field rather than while it writes one.
+ *
+ * `createFormDraftSchema()` composes these into the form's description. A
+ * caller using `createColumnSchema()` on its own has no root to carry them and
+ * should put {@link describeAuthoringRules} in the system prompt instead.
+ */
+/**
+ * The shape of a control name: lowerCamelCase, letters and digits only.
+ *
+ * Narrower than the engine, which also allows underscores — narrower is the
+ * permitted direction, and one convention is easier to follow than two.
+ * Exported so a test can hold the reserved-names rule to it: a reserved name
+ * the pattern would accept must be named in the rules, and one it rejects
+ * need not be.
+ */
+export const CONTROL_NAME_PATTERN = '^[a-z][a-zA-Z0-9]*$';
+/**
+ * The reserved names the pattern alone does not stop.
+ *
+ * `_id` and the `SYSTEM_*` inputs fail the pattern and need no mention;
+ * `reference`, `status` and `data` pass it, so the rule has to carry them.
+ * Filtered at evaluation rather than listed by hand, so the sentence says
+ * exactly what the pattern leaves open — no more, which would be noise, and no
+ * less, which would be a hole.
+ */
+const RESERVED_WELL_FORMED_NAMES = RESERVED_CONTROL_NAMES.filter((name) => new RegExp(CONTROL_NAME_PATTERN).test(name));
+/**
+ * The rules, one sentence group each, in the order the guide states them:
+ * naming, words, types, what the engine reads, layout, error timing.
+ */
+export const AUTHORING_RULES = [
+    `Control names are unique across the whole form and across every other form of the same workflow unless the same answer is deliberately carried forward, never change once the form is live, and are never one of the names the transaction document already owns: ${RESERVED_WELL_FORMED_NAMES.join(', ')}.`,
+    "A label never explains — that is the hint's job. Required fields are marked automatically, so add '(optional)' to the label of a field that is not required. A hint gives the format ('As it appears on your ID document, 13 digits'), the source ('Top right of the invoice, starts with INV') or the reason for asking something sensitive ('Used only to send delivery updates by SMS'); every field that could be misunderstood gets one.",
+    'Set type and dataType to the data. A number is never left as text: the engine compares strictly, so a number stored as text never equals a number. A phone number is type tel with dataType string.',
+    'A review decision toggle, a date the engine schedules on and any value a decision gate reads are always required and never conditionally hidden.',
+    'Related short values share one row (start and end as 6 and 6; quantity, unit price and line total as 4, 4 and 4); a textarea, an item list, a picker, an uploader or a signature never shares a row; the same kind of field keeps the same width all the way down a slide.',
+    'Errors are shown only after the user has left a field, so onlySetTempErrorOnTouch is true on nearly every field.',
+];
+/** The rules as one paragraph, for a form description or a system prompt. */
+export function describeAuthoringRules() {
+    return AUTHORING_RULES.join(' ');
+}

package/dist/skillet/extra-members.d.ts

@@ -0,0 +1,143 @@
+import { s } from '@hashbrownai/core';
+import type { FormColumnInputs } from '../interfaces/Form/index.js';
+import { FormInputKeys, SpecialElementKeys } from '../interfaces/FormBuilder/FormInputKeys.js';
+import { AssertNever } from './internal/coupling.js';
+import { type TableConfigDraft } from './members/table.js';
+/**
+ * The members an element can carry that `AllFormInputPrimaryKeys` does not
+ * declare.
+ *
+ * `DefaultInputConfig[element].properties` is typed
+ * `Array<FormInputKeys | SpecialElementKeys | AllFormInputPrimaryKeys>`, and it
+ * uses all three. Keying the main registry on `AllFormInputPrimaryKeys` alone
+ * left fourteen keys unresolvable at assembly time, including `pattern` and
+ * `placeholder` — properties too ordinary for a form generator to do without.
+ *
+ * ## `properties` is not a property list
+ *
+ * It is the list of ROWS the settings panel shows for that element, which is a
+ * superset of what the input stores. `matOptionsApiCall` and
+ * `showAllMcoaSegments` open editors; they are not keys on a form input and no
+ * interface declares them. Those are recorded in {@link EDITOR_ONLY_KEYS} and
+ * skipped during assembly — absent by intent, not by oversight.
+ *
+ * Enum membership does not decide this, which is worth stating because it looks
+ * like it should: `multipleInputAvailableOperations` sits in
+ * `SpecialElementKeys` beside the editor directives, yet `IMultiple` really
+ * does declare it. The test that settles it is whether an interface declares
+ * the key, so that is the test used.
+ */
+/** The type an extra member must produce, read off the real interface. */
+type MemberValue<K extends string> = K extends keyof FormColumnInputs ? NonNullable<FormColumnInputs[K]> : unknown;
+/**
+ * Keys that open an editor rather than store a value. They appear in
+ * `properties` and must never appear in a generation schema.
+ */
+export declare const EDITOR_ONLY_KEYS: readonly [SpecialElementKeys.FormValueFromInputSelector, SpecialElementKeys.FormInputSelector, SpecialElementKeys.MatOptionsApiCall, SpecialElementKeys.MatOptionsRequiredInputs, SpecialElementKeys.MatOptionsApiValueAccessRules, SpecialElementKeys.DefaultCalculatedFieldRules, SpecialElementKeys.MatOptionsItemType, SpecialElementKeys.MatOptionsSelectionOptions, SpecialElementKeys.DefaultValuePipe, SpecialElementKeys.DefaultCurrencySelect, SpecialElementKeys.DefaultDecimalNumberInput, SpecialElementKeys.Default, SpecialElementKeys.ShowAllMcoaSegments];
+/**
+ * Extra members still to be modelled.
+ *
+ * The four date bounds are all typed `Date`. A model emits JSON, so the best it
+ * can produce is an ISO string, which is not assignable to `Date` — they need
+ * the same draft-and-expand treatment as `matOptions` rather than a quiet
+ * mistyping. `tableConfig` and `matrixTableConfig` are nested configuration
+ * objects awaiting their own modules.
+ */
+export declare const PENDING_EXTRA_MEMBERS: readonly [FormInputKeys.StartMinDate, FormInputKeys.StartMaxDate, FormInputKeys.EndMinDate, FormInputKeys.EndMaxDate];
+/**
+ * Extra members whose schema produces an AUTHORING DRAFT rather than the stored
+ * shape — the same category `DRAFT_INPUT_MEMBERS` defines in
+ * `input-members.ts`, for keys that live in the other two enums.
+ *
+ * `tableConfig` is the only one. Its `columnsConfig` is keyed by column name —
+ * an index signature, which Skillet has no node for — so the model emits an
+ * ARRAY of columns each carrying its own key, and the application folds that
+ * into the record. See `members/table.ts`.
+ */
+export declare const DRAFT_EXTRA_MEMBERS: readonly [FormInputKeys.TableConfig];
+/** The draft each drafted extra member is held to. */
+interface ExtraMemberDrafts {
+    [FormInputKeys.TableConfig]: TableConfigDraft;
+}
+export declare const extraDraftMemberSchemas: {
+    tableConfig: s.ObjectType<{
+        displayedColumnsInOrder: s.ArrayType<s.StringType>;
+        columns: s.ArrayType<s.ObjectType<{
+            key: s.StringType;
+            type: s.EnumType<["caluculated", "property", "checkBox", "primaryKey"]>;
+            property: s.StringType;
+            label: s.StringType;
+            inEdit: s.BooleanType;
+            checkUpto: s.StringType;
+            calculatedFieldRules: 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: import("..").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>;
+            }>;
+            reductionFunction: import("@hashbrownai/core/src/schema/base").SchemaForUnion<"sum" | null>;
+            colorScale: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+        }>>;
+    }>;
+};
+export declare const extraInputMemberSchemas: {
+    pattern: s.StringType;
+    placeholder: s.StringType;
+    autocomplete: s.EnumType<import("..").AutocompleteOptions[]>;
+    disabled: s.BooleanType;
+    prefixText: s.StringType;
+    suffixText: s.StringType;
+    prefixIcon: s.StringType;
+    suffixIcon: s.StringType;
+    selectUpto: s.IntegerType;
+    showTotalsOf: s.ArrayType<s.StringType>;
+    multipleInputAvailableOperations: s.ArrayType<s.EnumType<import("..").MultipleInputAvailableOperations[]>>;
+    matrixTableConfig: s.ObjectType<{
+        dataSource: s.StringType;
+    }>;
+};
+export type ExtraMemberKey = keyof typeof extraInputMemberSchemas;
+type EditorOnlyKey = (typeof EDITOR_ONLY_KEYS)[number];
+type PendingExtraKey = (typeof PENDING_EXTRA_MEMBERS)[number];
+type DraftExtraKey = (typeof DRAFT_EXTRA_MEMBERS)[number];
+/**
+ * Every `FormInputKeys` and `SpecialElementKeys` member is accounted for —
+ * modelled, deferred, declared editor-only, or already covered by the primary
+ * registry because both enums spell the same key.
+ */
+export type _EveryExtraKeyClassified = AssertNever<Exclude<FormInputKeys | SpecialElementKeys, ExtraMemberKey | EditorOnlyKey | PendingExtraKey | DraftExtraKey | FormInputKeys.Accept | FormInputKeys.ConditionalInputConfig | FormInputKeys.GroupBy>>;
+/** Every extra node produces a value its interface member can hold. */
+export type _NoExtraValueDrift = AssertNever<{
+    [K in ExtraMemberKey]: [
+        s.Infer<(typeof extraInputMemberSchemas)[K]>
+    ] extends [MemberValue<K>] ? never : K;
+}[ExtraMemberKey]>;
+/** Every drafted extra node produces the draft it declares. */
+export type _NoExtraDraftDrift = AssertNever<{
+    [K in DraftExtraKey]: [
+        s.Infer<(typeof extraDraftMemberSchemas)[K]>
+    ] extends [ExtraMemberDrafts[K]] ? never : K;
+}[DraftExtraKey]>;
+/** Runtime key lists, derived from the enums. */
+export declare const ALL_FORM_INPUT_KEYS: FormInputKeys[];
+export declare const ALL_SPECIAL_ELEMENT_KEYS: SpecialElementKeys[];
+export {};

package/dist/skillet/extra-members.js

@@ -0,0 +1,79 @@
+import { s } from '@hashbrownai/core';
+import { FormInputKeys, SpecialElementKeys, } from '../interfaces/FormBuilder/FormInputKeys.js';
+import { enumValues } from './internal/coupling.js';
+import { describe } from './internal/editor-guidance.js';
+import { autocompleteSchema, multipleInputOperationSchema } from './shared-types.js';
+import { matrixTableConfigSchema, tableConfigSchema, } from './members/table.js';
+/**
+ * Keys that open an editor rather than store a value. They appear in
+ * `properties` and must never appear in a generation schema.
+ */
+export const EDITOR_ONLY_KEYS = [
+    SpecialElementKeys.FormValueFromInputSelector,
+    SpecialElementKeys.FormInputSelector,
+    SpecialElementKeys.MatOptionsApiCall,
+    SpecialElementKeys.MatOptionsRequiredInputs,
+    SpecialElementKeys.MatOptionsApiValueAccessRules,
+    SpecialElementKeys.DefaultCalculatedFieldRules,
+    SpecialElementKeys.MatOptionsItemType,
+    SpecialElementKeys.MatOptionsSelectionOptions,
+    SpecialElementKeys.DefaultValuePipe,
+    SpecialElementKeys.DefaultCurrencySelect,
+    SpecialElementKeys.DefaultDecimalNumberInput,
+    SpecialElementKeys.Default,
+    SpecialElementKeys.ShowAllMcoaSegments,
+];
+/**
+ * Extra members still to be modelled.
+ *
+ * The four date bounds are all typed `Date`. A model emits JSON, so the best it
+ * can produce is an ISO string, which is not assignable to `Date` — they need
+ * the same draft-and-expand treatment as `matOptions` rather than a quiet
+ * mistyping. `tableConfig` and `matrixTableConfig` are nested configuration
+ * objects awaiting their own modules.
+ */
+export const PENDING_EXTRA_MEMBERS = [
+    FormInputKeys.StartMinDate,
+    FormInputKeys.StartMaxDate,
+    FormInputKeys.EndMinDate,
+    FormInputKeys.EndMaxDate,
+];
+/**
+ * Extra members whose schema produces an AUTHORING DRAFT rather than the stored
+ * shape — the same category `DRAFT_INPUT_MEMBERS` defines in
+ * `input-members.ts`, for keys that live in the other two enums.
+ *
+ * `tableConfig` is the only one. Its `columnsConfig` is keyed by column name —
+ * an index signature, which Skillet has no node for — so the model emits an
+ * ARRAY of columns each carrying its own key, and the application folds that
+ * into the record. See `members/table.ts`.
+ */
+export const DRAFT_EXTRA_MEMBERS = [FormInputKeys.TableConfig];
+export const extraDraftMemberSchemas = {
+    [FormInputKeys.TableConfig]: tableConfigSchema,
+};
+export const extraInputMemberSchemas = {
+    [FormInputKeys.Pattern]: s.string(describe("A regular expression the typed value must match, as a JavaScript pattern without delimiters. Only for a code with a fixed shape that nothing looks up, such as an ID number or an order reference; never on a lookup key such as a supplier number, where the endpoint's error is the check.", FormInputKeys.Pattern)),
+    // Each authored sentence below is the DEFINITION only. The advice that goes
+    // with it — give an example, turn autofill off for one-time values, when a
+    // selection cap applies at all — is written once, on the editor row, and
+    // composed in by `describe()`. Saying it in both places produced descriptions
+    // that made the same point twice in slightly different words.
+    [FormInputKeys.Placeholder]: s.string(describe('Ghost text shown inside the field while it is empty. Prefer none: it disappears as the user types and screen readers may skip it, so anything that matters belongs in the hint.', FormInputKeys.Placeholder)),
+    [FormInputKeys.Autocomplete]: autocompleteSchema,
+    [FormInputKeys.Disabled]: s.boolean(describe('Whether the control is rendered but cannot be interacted with.', FormInputKeys.Disabled)),
+    [FormInputKeys.PrefixText]: s.string(describe('Short static text shown before the field, for example a currency symbol. It stops the user typing the unit into the box.', FormInputKeys.PrefixText)),
+    [FormInputKeys.SuffixText]: s.string(describe('Short static text shown after the field, for example a unit such as kg or %. It stops the user typing the unit into the box.', FormInputKeys.SuffixText)),
+    [FormInputKeys.PrefixIcon]: s.string(describe('Name of the Material icon shown before the field.', FormInputKeys.PrefixIcon)),
+    [FormInputKeys.SuffixIcon]: s.string(describe('Name of the Material icon shown after the field.', FormInputKeys.SuffixIcon)),
+    // The applicability rule is the valuable half here: the editor row declares
+    // `allowMultipleSelection === true`, and Skillet cannot express that
+    // structurally, so it arrives as the sentence a model actually needs.
+    [FormInputKeys.SelectUpto]: s.integer(describe('The most options the user may choose at once.', FormInputKeys.SelectUpto), { minimum: 1 }),
+    [FormInputKeys.ShowTotalsOf]: s.array(describe("The formControlNames of columns inside this list whose values are summed and shown as a total. For the user's eyes only: a total used anywhere else must also be a calculated field on the form itself.", FormInputKeys.ShowTotalsOf), s.string('A formControlName inside this list to total.')),
+    [SpecialElementKeys.MultipleInputAvailableOperations]: s.array(describe("Which operations the user may perform on the rows of this repeatable group: usually 'add', 'remove' and 'update'; add 'lockEditOnFormSubmit' when rows must not change once submitted.", SpecialElementKeys.MultipleInputAvailableOperations), multipleInputOperationSchema),
+    [FormInputKeys.MatrixTableConfig]: matrixTableConfigSchema,
+};
+/** Runtime key lists, derived from the enums. */
+export const ALL_FORM_INPUT_KEYS = enumValues(FormInputKeys);
+export const ALL_SPECIAL_ELEMENT_KEYS = enumValues(SpecialElementKeys);