ngx-t-forms-types 0.0.30 → 0.0.33

package/dist/skillet/form.js

@@ -0,0 +1,139 @@
+import { s } from '@hashbrownai/core';
+import { ElementTypes } from '../interfaces/formInput/index.js';
+import { describeAuthoringRules } from './authoring-rules.js';
+import { optional } from './internal/coupling.js';
+import { CALCULATED_FIELD_DRAFT_COMPLETION } from './members/calculated-field.js';
+import { CONDITIONAL_DRAFT_COMPLETION } from './members/conditional.js';
+import { WORKFLOW_PICKER_DRAFT_COMPLETION } from './members/document-picker.js';
+import { MAT_OPTIONS_DRAFT_COMPLETION, } from './members/mat-options.js';
+import { MSCOA_DRAFT_COMPLETION } from './members/mscoa.js';
+import { PAGINATION_DRAFT_COMPLETION } from './members/pagination.js';
+import { TABLE_DRAFT_COMPLETION } from './members/table.js';
+import { VALIDATOR_DRAFT_COMPLETION } from './members/validators.js';
+import { CALCULATE_LIST_DRAFT_COMPLETION } from './members/value.js';
+import { createColumnSchema } from './variants.js';
+import { describeWorkflowStep, } from './workflow-context.js';
+function submissionHandleSchema(endpoints, canSubmitEndpoints) {
+    const endpointNode = endpoints.length
+        ? s.enumeration(`Which configured endpoint the completed form is submitted to. Choose by meaning: ${endpoints
+            .map((e) => `${e.id} (${e.name})`)
+            .join('; ')}.`, endpoints.map((e) => e.id))
+        : s.string('Leave this list empty. No submission endpoints were offered, so one cannot be chosen and must not be invented.');
+    const submissionAPI = s.array(endpoints.length
+        ? 'The endpoint the form submits to. Choose exactly one.'
+        : 'Leave empty — the application supplies the submission endpoint.', endpointNode, endpoints.length ? { minItems: 1, maxItems: 1 } : { maxItems: 0 });
+    // `innerComponentShowSubmitButton` is deliberately absent: it is deprecated,
+    // and a deprecated property left in a generation schema comes back on every
+    // form the model writes.
+    const submissionMessage = optional(s.string("Message shown to the user after a successful submission. One sentence, past tense, saying what happened and what happens next: 'Your requisition has been submitted and sent to your line manager for approval'."));
+    const description = 'How the completed form is submitted.';
+    // Two whole object nodes rather than one with a conditionally spread key:
+    // an optional key in a Skillet shape infers as `unknown`, which would leave
+    // the assertion at the foot of this file passing while proving nothing.
+    return canSubmitEndpoints.length
+        ? s.object(description, {
+            submissionAPI,
+            canSubmitAPI: s.array('An optional check run before the form is submitted: the endpoint is called with the form data and must approve before the submission proceeds. Leave this empty unless the form genuinely needs a gate — most do not. Choose at most one.', s.enumeration(`Which configured endpoint decides whether the form may be submitted. Choose by meaning: ${canSubmitEndpoints
+                .map((e) => `${e.id} (${e.name})`)
+                .join('; ')}.`, canSubmitEndpoints.map((e) => e.id)), { maxItems: 1 }),
+            submissionMessage,
+        })
+        : s.object(description, {
+            submissionAPI,
+            submissionMessage,
+        });
+}
+/**
+ * Builds the form-draft schema.
+ *
+ * @param options which elements and data sources to offer, which endpoints the
+ *   form may submit to and which may gate that submission, and whether to
+ *   stream.
+ */
+export function createFormDraftSchema(options = {}) {
+    const column = createColumnSchema(options);
+    const array = options.streaming ? s.streaming.array : s.array;
+    const object = options.streaming ? s.streaming.object : s.object;
+    // The guide's grouping rule names section titles, so it is only stated when
+    // that element is actually on offer — a sentence pointing a model at an
+    // element it cannot choose is an invitation to invent one.
+    const offersHeadings = (options.elements ?? Object.values(ElementTypes)).includes(ElementTypes.SectionTitle);
+    const slide = object('A page of the form: one topic, with five to seven fields, an item list counting as one. Over eight, split it. Its label becomes a section heading when the transaction is read back.', {
+        label: s.string("The heading for this page: a short statement of what it holds, in sentence case — 'Requester details', 'Items required' — never a question, a verb, or a number such as 'Section 3'."),
+        columns: array([
+            'The fields on this page, in the order they are shown: identifiers and choices first, free text, uploads, calculations and signatures last.',
+            offersHeadings
+                ? 'Start each group of three to five related fields with a sectionTitle whose hintLabel carries the guidance for the group.'
+                : null,
+            'Fields that belong together share one row by sharing out the 12 grid columns between them, and a field revealed by a condition sits immediately after the field that reveals it.',
+        ]
+            .filter((part) => part !== null)
+            .join(' '), column, { minItems: 1 }),
+    });
+    // The root is emitted exactly once, so it is where the form-wide rules go;
+    // see `authoring-rules.ts` for why they are not on the members themselves.
+    const formDescription = [
+        'A complete dynamic form. Group related fields onto slides rather than one long page; a form of fewer than about seven fields fits on one slide. Make the system do everything it can: prefill what it knows, calculate what it can derive, and let the user pick rather than type.',
+        describeAuthoringRules(),
+        options.step ? describeWorkflowStep(options.step) : null,
+    ]
+        .filter((part) => part !== null)
+        .join(' ');
+    return object(formDescription, {
+        formTitle: s.string('The title of the form, in sentence case. Name what the form is for.'),
+        slides: array('The pages of the form, in order.', slide, { minItems: 1 }),
+        submissionHandle: submissionHandleSchema(options.submissionEndpoints ?? [], options.canSubmitEndpoints ?? []),
+    });
+}
+/**
+ * Members of a generated draft the application must supply before the form is
+ * valid. Listed so the expansion step has something to check itself against.
+ *
+ * The per-member lists are pulled in rather than restated, so a module that
+ * takes on a new obligation adds it here by existing. Each entry is prefixed
+ * with the column path it hangs off, since the modules describe their own
+ * shape and do not know where in a form they sit.
+ *
+ * A module's own entries must therefore start at the MEMBER it owns —
+ * `validators[].id`, not `id` — because everything before that is added here
+ * and everything after is the module's to state. A list that skips its member
+ * name yields a path with a hole in it, which is worse than no list: it reads
+ * as authoritative and points nowhere.
+ *
+ * Three entries are not from any module and are worth reading twice:
+ *
+ * - `isCalculatedField` is derived, not authored — see `calculatedFieldSplit`
+ *   in `variants.ts`. It is required by the interface on EVERY column, so
+ *   expansion must set it on plain columns too, not only calculated ones.
+ * - `onlySetTempErrorOnTouch` is required by the interface but optional in the
+ *   schema (offered on every value-capturing element through the always-shown
+ *   editor rows), so a model may leave it null. Expansion then sets it, and the
+ *   guide's house rule says what to: true, so errors appear only after the
+ *   user leaves a field. The builder's own element templates default it to
+ *   false; the guide is explicit that this is the wrong default for nearly
+ *   every field.
+ * - the nulls. Skillet has no optional, so every unset member arrives as an
+ *   explicit `null`, and Joi rejects `null` for a typed optional key. Stripping
+ *   them is not tidying; a draft that keeps them fails validation.
+ */
+export const DRAFT_COMPLETION_REQUIRED = [
+    'slides[].sectionId',
+    'slides[].columns[].id',
+    'slides[].columns[].sectionId',
+    'slides[].columns[].isCalculatedField (derived: calculatedFieldRules != null)',
+    'slides[].columns[].onlySetTempErrorOnTouch (required by the interface and offered as optional; when the model leaves it null the application sets true)',
+    'submissionHandle.submissionAPI[] (endpoint id expanded to its configuration)',
+    'submissionHandle.canSubmitAPI[] (endpoint id expanded to its configuration; the key is present only when canSubmitEndpoints were offered, and an empty array is dropped)',
+    ...[
+        ...CALCULATED_FIELD_DRAFT_COMPLETION,
+        ...VALIDATOR_DRAFT_COMPLETION,
+        ...CONDITIONAL_DRAFT_COMPLETION,
+        ...PAGINATION_DRAFT_COMPLETION,
+        ...MSCOA_DRAFT_COMPLETION,
+        ...WORKFLOW_PICKER_DRAFT_COMPLETION,
+        ...MAT_OPTIONS_DRAFT_COMPLETION,
+        ...CALCULATE_LIST_DRAFT_COMPLETION,
+        ...TABLE_DRAFT_COMPLETION,
+    ].map((path) => `slides[].columns[].${path}`),
+    'every member emitted as null is stripped before validation',
+];

package/dist/skillet/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Skillet schemas for LLM-driven form authoring.
+ *
+ * Published as the `ngx-t-forms-types/skillet` subpath, NOT from the package
+ * root, because it is the only part of these typings that needs
+ * `@hashbrownai/core`. That dependency is an optional peer: consumers who never
+ * generate forms — the Node API, existing Angular apps — resolve the root entry
+ * and never load it.
+ *
+ * ## What this is for
+ *
+ * These schemas describe form structure to a model so it can author one. They
+ * are a GENERATION contract, not a validation contract. The Joi schemas under
+ * `src/schemas` remain the source of truth: a generated form is validated with
+ * `validateForm()` exactly like a hand-built one, and failures are fed back to
+ * the model as a repair turn. Where the two disagree, Joi wins.
+ *
+ * ## How drift is prevented
+ *
+ * Enum-backed nodes read their entries from the live enums at evaluation, so
+ * they cannot fall behind. Everything else is checked at compile time: see the
+ * assertions at the foot of `input-members.ts`, which fail the build — by
+ * name — when a key is added to `AllFormInputPrimaryKeys`, when a member is
+ * left unclassified, or when a node starts producing a value its interface
+ * cannot hold.
+ */
+export { enumValues, exhaustive, matches, optional, type AssertNever, } from './internal/coupling.js';
+export * from './shared-types.js';
+export * from './input-members.js';
+export * from './extra-members.js';
+export * from './members/mat-options.js';
+export * from './members/calculated-field.js';
+export * from './members/validators.js';
+export * from './members/conditional.js';
+export * from './members/document-picker.js';
+export * from './members/mscoa.js';
+export * from './members/pagination.js';
+export * from './members/table.js';
+export * from './members/value.js';
+export * from './variants.js';
+export * from './form.js';
+export * from './workflow-context.js';
+export * from './authoring-rules.js';

package/dist/skillet/index.js

@@ -0,0 +1,46 @@
+/**
+ * Skillet schemas for LLM-driven form authoring.
+ *
+ * Published as the `ngx-t-forms-types/skillet` subpath, NOT from the package
+ * root, because it is the only part of these typings that needs
+ * `@hashbrownai/core`. That dependency is an optional peer: consumers who never
+ * generate forms — the Node API, existing Angular apps — resolve the root entry
+ * and never load it.
+ *
+ * ## What this is for
+ *
+ * These schemas describe form structure to a model so it can author one. They
+ * are a GENERATION contract, not a validation contract. The Joi schemas under
+ * `src/schemas` remain the source of truth: a generated form is validated with
+ * `validateForm()` exactly like a hand-built one, and failures are fed back to
+ * the model as a repair turn. Where the two disagree, Joi wins.
+ *
+ * ## How drift is prevented
+ *
+ * Enum-backed nodes read their entries from the live enums at evaluation, so
+ * they cannot fall behind. Everything else is checked at compile time: see the
+ * assertions at the foot of `input-members.ts`, which fail the build — by
+ * name — when a key is added to `AllFormInputPrimaryKeys`, when a member is
+ * left unclassified, or when a node starts producing a value its interface
+ * cannot hold.
+ */
+export { enumValues, exhaustive, matches, optional, } from './internal/coupling.js';
+export * from './shared-types.js';
+export * from './input-members.js';
+export * from './extra-members.js';
+// Per-member modules. Each owns one nested configuration object, states why it
+// produces a draft where it does, and lists what the application must supply
+// before that draft is valid.
+export * from './members/mat-options.js';
+export * from './members/calculated-field.js';
+export * from './members/validators.js';
+export * from './members/conditional.js';
+export * from './members/document-picker.js';
+export * from './members/mscoa.js';
+export * from './members/pagination.js';
+export * from './members/table.js';
+export * from './members/value.js';
+export * from './variants.js';
+export * from './form.js';
+export * from './workflow-context.js';
+export * from './authoring-rules.js';

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 {};