ngx-t-forms-types 0.0.30 → 0.0.34

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

@@ -0,0 +1,375 @@
+import { s } from '@hashbrownai/core';
+import type { FormColumnInputs } from '../interfaces/Form/index.js';
+import { AllFormInputPrimaryKeys } from '../interfaces/FormBuilder/FormInputKeys.js';
+import { type MatOptionsDraft } from './members/mat-options.js';
+import { type CalculatedFieldRulesDraft } from './members/calculated-field.js';
+import { type ValidatorEntryDraft } from './members/validators.js';
+import { type ConditionalRuleDraft } from './members/conditional.js';
+import { type MscoaConfigDraft } from './members/mscoa.js';
+import { type PaginationSelectionConfigDraft } from './members/pagination.js';
+import { type CalculateListFunctionsDraft } from './members/value.js';
+import { AssertNever } from './internal/coupling.js';
+/**
+ * One Skillet node per member a form input can carry.
+ *
+ * This registry is the single place a property's LLM-facing shape is defined.
+ * Per-element variants are assembled by PICKING from it — they never redeclare
+ * a node — so a property means the same thing everywhere it appears.
+ *
+ * ## Nodes are unwrapped
+ *
+ * Every node here describes the value as it looks WHEN PRESENT. Optionality is
+ * not encoded, because it is not a property of the member — it is a property of
+ * the member *within an element*. `colSize` is required on an input and absent
+ * on a section title. Variant assembly consults
+ * `DefaultInputConfig[element].requiredProperties` and wraps the optional ones
+ * with `optional()` at that point.
+ *
+ * ## Descriptions are composed, not written twice
+ *
+ * Each authored description is passed through `describe()`, which layers on the
+ * hint and the applicability rules the form-builder's own editor config already
+ * carries for that property. See `internal/editor-guidance.ts` for what is
+ * drawn from there and what was inspected and deliberately rejected.
+ *
+ * ## The five categories are exhaustive
+ *
+ * Every `AllFormInputPrimaryKeys` member belongs to exactly one of
+ * {@link inputMemberSchemas}, {@link draftMemberSchemas},
+ * {@link PENDING_INPUT_MEMBERS}, {@link SYSTEM_OWNED_INPUT_MEMBERS}, or
+ * {@link DEPRECATED_INPUT_MEMBERS}. The assertions at the foot of this file
+ * prove it, so a key added to the enum breaks the build until it is
+ * classified. Nothing can be silently forgotten.
+ */
+/**
+ * The type a member is required to produce, read off the real interface.
+ *
+ * Keys the interfaces do not declare resolve to `unknown`, which imposes no
+ * constraint — see {@link UnbackedInputMember} for why that is a finding rather
+ * than a feature.
+ */
+type MemberValue<K extends AllFormInputPrimaryKeys> = K extends keyof FormColumnInputs ? NonNullable<FormColumnInputs[K]> : unknown;
+/**
+ * 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 declare const SYSTEM_OWNED_INPUT_MEMBERS: readonly [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 declare const DEPRECATED_INPUT_MEMBERS: readonly [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 declare const PENDING_INPUT_MEMBERS: readonly [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 declare const ASSEMBLED_INPUT_MEMBERS: readonly [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 declare const DRAFT_INPUT_MEMBERS: readonly [AllFormInputPrimaryKeys.MatOptions, AllFormInputPrimaryKeys.CalculatedFieldRules, AllFormInputPrimaryKeys.Validators, AllFormInputPrimaryKeys.ConditionalInputConfig, AllFormInputPrimaryKeys.MscoaConfig, AllFormInputPrimaryKeys.PaginationSelectionConfig, AllFormInputPrimaryKeys.CalculateListFunctions];
+type SystemOwnedKey = (typeof SYSTEM_OWNED_INPUT_MEMBERS)[number];
+type DeprecatedKey = (typeof DEPRECATED_INPUT_MEMBERS)[number];
+type PendingKey = (typeof PENDING_INPUT_MEMBERS)[number];
+type DraftKey = (typeof DRAFT_INPUT_MEMBERS)[number];
+type AssembledKey = (typeof ASSEMBLED_INPUT_MEMBERS)[number];
+/**
+ * The draft each drafted member is held to.
+ *
+ * Every one of these exists because the stored shape carries an identifier the
+ * builder assigns — an input's `id`, a rule's `id`, a segment's row key. A
+ * model authoring a form that does not exist yet cannot know any of them, so it
+ * binds by `formControlName` and the application resolves the pair. Each
+ * module states its own version of this; the list is here so the compiler
+ * checks them all in one place.
+ */
+interface MemberDrafts {
+    [AllFormInputPrimaryKeys.MatOptions]: MatOptionsDraft;
+    [AllFormInputPrimaryKeys.CalculatedFieldRules]: CalculatedFieldRulesDraft;
+    [AllFormInputPrimaryKeys.Validators]: ValidatorEntryDraft[];
+    [AllFormInputPrimaryKeys.ConditionalInputConfig]: ConditionalRuleDraft[];
+    [AllFormInputPrimaryKeys.MscoaConfig]: MscoaConfigDraft;
+    [AllFormInputPrimaryKeys.PaginationSelectionConfig]: PaginationSelectionConfigDraft;
+    [AllFormInputPrimaryKeys.CalculateListFunctions]: CalculateListFunctionsDraft;
+}
+/**
+ * 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 declare const draftMemberSchemas: {
+    matOptions: s.ObjectType<{
+        optionType: import("@hashbrownai/core/src/schema/base").SchemaForUnion<"user" | null>;
+        options: s.ArrayType<s.ObjectType<{
+            label: s.StringType;
+            value: s.StringType;
+        }>>;
+        fetch: s.ObjectType<{
+            value: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
+                source: import("..").DataSources.Local;
+                inputSourceId: string;
+                allowManualValueEntry: boolean;
+            } | {
+                source: import("..").DataSources.CustomOptions;
+            } | {
+                source: import("..").DataSources.Api;
+                endpointId: string;
+                allowManualValueEntry: boolean;
+            } | {
+                source: import("..").DataSources.MongoDb;
+                workflowId: string;
+            } | null>;
+            options: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
+                source: import("..").DataSources.Local;
+                inputSourceId: string;
+                allowManualValueEntry: boolean;
+            } | {
+                source: import("..").DataSources.CustomOptions;
+            } | {
+                source: import("..").DataSources.Api;
+                endpointId: string;
+                allowManualValueEntry: boolean;
+            } | {
+                source: import("..").DataSources.MongoDb;
+                workflowId: string;
+            } | null>;
+        }>;
+    }>;
+    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>;
+    }>;
+    validators: s.ArrayType<import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | {
+        message: string;
+        expression: string;
+        canOverride: boolean;
+        inputsObservedForChanges: {
+            formControlName: string;
+            variable: string;
+            parentInputFormControl: string | null;
+            function: import("..").CalculationFunctions | null;
+        }[];
+    }>> | s.ArrayType<s.ObjectType<{
+        message: s.StringType;
+        expression: s.StringType;
+        canOverride: s.BooleanType;
+        inputsObservedForChanges: s.ArrayType<s.ObjectType<{
+            formControlName: s.StringType;
+            variable: s.StringType;
+            parentInputFormControl: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+            function: import("@hashbrownai/core/src/schema/base").SchemaForUnion<import("..").CalculationFunctions | null>;
+        }>>;
+    }>>;
+    conditionalInputConfig: s.ArrayType<s.ObjectType<{
+        expression: s.StringType;
+        inputsObservedForChanges: s.ArrayType<s.ObjectType<{
+            formControlName: s.StringType;
+            variable: s.StringType;
+            parentInputFormControl: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+            function: import("@hashbrownai/core/src/schema/base").SchemaForUnion<import("..").CalculationFunctions | null>;
+        }>>;
+    }>>;
+    mscoaConfig: s.ObjectType<{
+        accountingBasis: import("@hashbrownai/core/src/schema/base").SchemaForUnion<import("..").AccountingBasis | null>;
+        segments: s.ArrayType<s.ObjectType<{
+            segment: s.StringType;
+            customSegment: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | null>;
+            label: s.StringType;
+            readOnly: s.BooleanType;
+            singleSelect: s.BooleanType;
+            additionalAccounts: s.ArrayType<s.StringType>;
+            inheritValueFromAccrual: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
+            vatSelectonActive: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
+            segmentExtension: s.BooleanType;
+        }>>;
+        cashSegments: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
+            segment: string;
+            customSegment: string | null;
+            label: string;
+            readOnly: boolean;
+            singleSelect: boolean;
+            additionalAccounts: string[];
+            inheritValueFromAccrual: boolean | null;
+            vatSelectonActive: boolean | null;
+            segmentExtension: boolean;
+        }[] | null>;
+        accountValueLabel: s.EnumType<string[]>;
+        showAllSegments: s.BooleanType;
+        extensionAccountsForSegments: s.ArrayType<s.StringType>;
+        dualCashExclusion: import("@hashbrownai/core/src/schema/base").SchemaForUnion<{
+            rules: {
+                pattern: string;
+                flags: string | null;
+                matchField: string | null;
+                segment: string | null;
+                description: string | null;
+            }[] | null;
+            matchMode: "any" | "all" | null;
+        } | null>;
+    }>;
+    paginationSelectionConfig: s.ObjectType<{
+        useLocalPagination: import("@hashbrownai/core/src/schema/base").SchemaForUnion<boolean | null>;
+        columns: s.ArrayType<s.ObjectType<{
+            key: s.StringType;
+            label: s.StringType;
+        }>>;
+    }>;
+    calculateListFunctions: s.ArrayType<s.ObjectType<{
+        formControlName: s.StringType;
+        func: s.EnumType<import("..").CalculationFunctions[]>;
+    }>>;
+};
+/** Every key this registry is obliged to cover. */
+export type ModelledKey = Exclude<AllFormInputPrimaryKeys, SystemOwnedKey | PendingKey | DeprecatedKey | DraftKey | AssembledKey>;
+export declare const inputMemberSchemas: {
+    element: s.EnumType<import("..").ElementTypes[]>;
+    label: s.StringType;
+    formControlName: s.StringType;
+    colSize: s.IntegerType;
+    appearance: s.EnumType<["fill", "outline"]>;
+    dataType: s.EnumType<import("..").InputDataTypes[]>;
+    type: s.EnumType<import("..").InputTypes[]>;
+    viewType: s.EnumType<import("../interfaces/formInput/BasicFormInputInterface.js").InputViewTypes.ViewOnly[]>;
+    required: s.BooleanType;
+    readonly: s.BooleanType;
+    showAsLabel: s.BooleanType;
+    onlySetTempErrorOnTouch: s.BooleanType;
+    isCalculatedField: s.BooleanType;
+    hintLabel: s.StringType;
+    tourContent: s.StringType;
+    spellcheck: s.BooleanType;
+    autocapitalize: s.EnumType<import("..").AutocapitalizeOptions[]>;
+    rows: s.IntegerType;
+    wrap: s.EnumType<["hard", "soft"]>;
+    richTextEditorLibrary: s.EnumType<import("..").RichTextEditorType[]>;
+    min: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | number>;
+    max: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | number>;
+    minLength: s.IntegerType;
+    maxLength: s.IntegerType;
+    optionSelectType: s.EnumType<import("..").OptionSelectTypes[]>;
+    allowMultipleSelection: s.BooleanType;
+    singleSelect: s.BooleanType;
+    groupBy: s.ArrayType<s.StringType>;
+    labelPosition: s.EnumType<import("../interfaces/formInput/ToggleInputInterface.js").LabelPosition[]>;
+    trueLabel: s.StringType;
+    falseLabel: s.StringType;
+    startDateControl: s.StringType;
+    endDateControl: s.StringType;
+    fileType: s.EnumType<import("..").InputFileType[]>;
+    accept: s.StringType;
+    handleLabel: s.StringType;
+    pipe: s.ObjectType<{
+        pipeType: s.EnumType<import("..").InputPipeTypes[]>;
+        param: s.StringType;
+    }>;
+    linkedSegmentId: s.StringType;
+    adjudicationStep: s.EnumType<import("..").AdjudicationSteps[]>;
+    adjudicationPointTypes: s.ArrayType<s.StringType>;
+    workflowFormForScoreSheet: s.StringType;
+    value: import("@hashbrownai/core/src/schema/base").SchemaForUnion<string | number | boolean>;
+    script: s.ObjectType<{
+        onChange: s.StringType;
+    }>;
+};
+/**
+ * Every key is classified. Adding a member to `AllFormInputPrimaryKeys` fails
+ * here until it is modelled, deferred, or declared system-owned.
+ */
+export type _EveryKeyClassified = AssertNever<Exclude<AllFormInputPrimaryKeys, ModelledKey | PendingKey | SystemOwnedKey | DeprecatedKey | DraftKey | AssembledKey>>;
+/**
+ * No key may be claimed by two categories at once.
+ *
+ * Written as each category against the union of those after it rather than as
+ * every pair spelled out: the pairwise form needed ten lines for five
+ * categories and would need fifteen for six, which is the kind of list that
+ * quietly loses an entry when the next category is added.
+ */
+export type _CategoriesDisjoint = AssertNever<(ModelledKey & (PendingKey | SystemOwnedKey | DeprecatedKey | DraftKey | AssembledKey)) | (PendingKey & (SystemOwnedKey | DeprecatedKey | DraftKey | AssembledKey)) | (SystemOwnedKey & (DeprecatedKey | DraftKey | AssembledKey)) | (DeprecatedKey & (DraftKey | AssembledKey)) | (DraftKey & AssembledKey)>;
+/**
+ * Every drafted node produces the draft it declares. The expansion from draft
+ * to stored shape is the caller's, but the draft itself stays checked.
+ */
+export type _NoDraftDrift = AssertNever<{
+    [K in DraftKey]: [s.Infer<(typeof draftMemberSchemas)[K]>] extends [
+        MemberDrafts[K]
+    ] ? never : K;
+}[DraftKey]>;
+/**
+ * Every modelled node still produces a value its interface member can hold.
+ * Retyping a member in the interfaces surfaces here, by name, as a constraint
+ * violation on the offending key.
+ *
+ * Narrowing is permitted by design — several nodes deliberately refuse value
+ * shapes the interface tolerates but a model should never invent.
+ */
+export type _NoValueDrift = AssertNever<{
+    [K in ModelledKey]: [s.Infer<(typeof inputMemberSchemas)[K]>] extends [
+        MemberValue<K>
+    ] ? never : K;
+}[ModelledKey]>;
+/**
+ * Keys the enum declares but no interface in this package backs, so
+ * {@link MemberValue} cannot constrain them and their nodes go unverified.
+ * Exported deliberately: this is pre-existing drift the schemas inherit, not
+ * something they introduce.
+ */
+export type UnbackedInputMember = Exclude<AllFormInputPrimaryKeys, keyof FormColumnInputs>;
+/** Runtime access to the full key list, derived from the enum. */
+export declare const ALL_INPUT_MEMBER_KEYS: AllFormInputPrimaryKeys[];
+export {};

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;