ngx-t-forms 2.0.29 → 2.0.31

package/types/ngx-t-forms.d.ts

@@ -1,65 +1,420 @@
-import * as i0 from '@angular/core';
-import { EnvironmentProviders, OnDestroy, InjectionToken, OnInit, EventEmitter, ElementRef, NgZone, SimpleChanges, PipeTransform } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { Provider, EnvironmentProviders, InjectionToken, OnInit, OnDestroy, Signal, PipeTransform, Type, ElementRef } from '@angular/core';
 import * as ngx_t_forms_types from 'ngx-t-forms-types';
-import { OLD_FormInterface, FormInterface, NgxTFormsConfig, FormColumnInputs, IFormChangeHistory, FormSubmissionStatus, ElementEditorInnerSectionElementInterface, InClassFormUtilsInterface, ValidationError, FormInputKeys, SpecialElementKeys, AllFormInputPrimaryKeys, ElementEditorTypes, FormInputBasicOptionInterface, TreeNode, IFormActions, IWorkflowDocumentPicker, IBasicFormInput, IFileUploadInput, IDateRangePickerInput, ITextareaProperties, IToggleInput, IMatrixInput, IMultiple, FormSlideInterface, IGetTreeResponse, DialogConfig, IFormsInitStateInterface, IStoreFunctions, FormsStoreSelectorsInterface, FormListSection, LocalFormStateSelectorInterface, ConfigurationValidTestInterface, IWorkflowOption, BlurHandleTypes, FlatNode, ITowerStepColumn, FormBuilderFunctions, ElementTypes, DocumentLitsLabelConfigInterfaceValueType, InputDataTypes, InputPipeTypes, FileUploadInputValueInterface, IArrayFunction } from 'ngx-t-forms-types';
-import { FormGroup, AbstractControl, FormControl } from '@angular/forms';
-import { IStepOption } from 'ngx-ui-tour-md-menu';
+import { NgxTFormsConfig, IFormActions, FormInterface, FormSlideInterface, InClassFormUtilsInterface, IWorkflowDocumentPicker, IBasicFormInput, IFileUploadInput, IDateRangePickerInput, ITextareaProperties, IToggleInput, IMatrixInput, IMultiple, IGetTreeResponse, IRunPipelineResponse, IPipelineGenerationResponse, LocalFormStateSelectorInterface, FormsStoreSelectorsInterface, FormListSection, WorkflowFunctionTypes, FileData, FormSubmissionStatus, IFormValidationOverride, FormColumnInputs, IFormChangeHistory, FormBuilderFunctions, ITowerFormSteps, ElementEditorTypes, ElementEditorInnerSectionElementInterface, IWorkflowOption, BlurHandleTypes, ITowerStepColumn, TreeNode, FlatNode, IArrayFunction, DocumentLitsLabelConfigInterfaceValueType, InputDataTypes, InputPipeTypes, ImportProgress, ImportRowState, ValidationError, FormInputBasicOptionInterface, ElementTypes, DialogConfig, PropertyPath, DeepPropertyValue, FileUploadInputValueInterface, FormInterfaceMigration, ConfigurationValidTestInterface, EncryptedData } from 'ngx-t-forms-types';
+export { BlurHandleTypes, ConfigurationValidTestInterface, DeepPropertyValue, DialogConfig, DocumentLitsLabelConfigInterfaceValueType, ElementEditorInnerSectionElementInterface, ElementEditorTypes, EncryptedData, FileUploadInputValueInterface, FormBuilderFunctions, FormColumnInputs, FormInterface, FormInterfaceMigration, FormListSection, FormSubmissionStatus, IArrayFunction, IFormActions, IFormChangeHistory, IFormTour, IFormValidationOverride, IGetTreeResponse, IScoaAccount, ITowerStepColumn, IWorkflowOption, ImportProgress, ImportRowState, ImportRowStatus, InClassFormUtilsInterface, InputDataTypes, InputPipeTypes, LocalFormStateSelectorInterface, NgxTFormsConfig, OLD_FormInterface, PropertyPath, TreeNode, ValidationError, WorkflowFunctionTypes } from 'ngx-t-forms-types';
 import * as rxjs from 'rxjs';
-import { Observable, Subject, Subscription, BehaviorSubject } from 'rxjs';
-import { HttpClient } from '@angular/common/http';
+import { Observable, Subject } from 'rxjs';
+import { PipelineStage } from 'mongoose';
+import { Router, ActivatedRoute } from '@angular/router';
+import { MatStepper } from '@angular/material/stepper';
 import { StepperSelectionEvent, StepState } from '@angular/cdk/stepper';
-import { MatDialogRef } from '@angular/material/dialog';
-import * as _angular_cdk_drag_drop from '@angular/cdk/drag-drop';
-import * as _angular_router from '@angular/router';
-import { ActivatedRoute, Router } from '@angular/router';
-import { ComponentStore } from '@ngrx/component-store';
-import { MatSnackBar } from '@angular/material/snack-bar';
+import { HttpClient } from '@angular/common/http';
+import { FormGroup, FormControl } from '@angular/forms';
+import * as ngx_ui_tour_md_menu from 'ngx-ui-tour-md-menu';
+import { IStepOption } from 'ngx-ui-tour-md-menu';
 import { FlatTreeControl } from '@angular/cdk/tree';
 import { MatTreeFlattener, MatTreeFlatDataSource } from '@angular/material/tree';
-import { MatStepper } from '@angular/material/stepper';
-import * as ngx_ui_tour_core from 'ngx-ui-tour-core';
+import { MatDialogRef } from '@angular/material/dialog';
 
-declare class NgxTFormsService {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTFormsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgxTFormsService>;
+/** @internal */
+declare const enum NgxTFormsFeatureKind {
+    SilencedConsole = 0,
+    FormBuilder = 1,
+    ImportTower = 2,
+    HttpPipeline = 3,
+    InputSecret = 4,
+    RouterFormId = 5
 }
+interface NgxTFormsFeature {
+    readonly kind: NgxTFormsFeatureKind;
+    readonly providers: Provider[];
+}
+/**
+ * Registers ngx-t-forms with the application injector.
+ *
+ * @param config Runtime configuration (form actions, builder, etc.).
+ * @param features Optional with*() extension features.
+ * @returns EnvironmentProviders ready to drop into `bootstrapApplication`.
+ *
+ * @example
+ *   bootstrapApplication(AppComponent, {
+ *     providers: [
+ *       provideNgxTForms(myConfig, withSilencedConsole(), withFormBuilder()),
+ *     ],
+ *   });
+ */
+declare function provideNgxTForms(config: NgxTFormsConfig, ...features: NgxTFormsFeature[]): EnvironmentProviders;
 
-declare class NgxTFormsComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTFormsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgxTFormsComponent, "lib-ngx-t-forms", never, {}, {}, never, never, true, never>;
+/**
+ * @public
+ *
+ * Binds the default HTTP-backed {@link HttpPipelineRepository} to
+ * {@link PIPELINE_REPOSITORY}. Required when the consumer uses any
+ * pipeline-running feature (e.g. the pipeline-generator UI) and wants the
+ * built-in HTTP transport.
+ *
+ * Consumers that supply their own {@link PipelineRepository} implementation
+ * should bind it directly to {@link PIPELINE_REPOSITORY} instead of (or after)
+ * calling this — provider order resolution applies.
+ *
+ * @example
+ *   bootstrapApplication(AppComponent, {
+ *     providers: [
+ *       provideHttpClient(),
+ *       provideNgxTForms(config, withHttpPipeline()),
+ *     ],
+ *   });
+ */
+declare function withHttpPipeline(): NgxTFormsFeature;
+
+/**
+ * Registers the HMAC secret used to derive per-input encryption keys for the
+ * signature input. Required only when the signature input is in use — if the
+ * token is unbound at the point of encryption/decryption the library throws a
+ * clear error rather than silently falling back to a baked-in default.
+ *
+ * @param secret High-entropy string supplied by the consumer (e.g. read from
+ *   their own `environment.ts` or a runtime config endpoint).
+ *
+ * @example
+ *   provideNgxTForms(
+ *     myConfig,
+ *     withInputSecret(environment.ngxTFormsInputSecret),
+ *   )
+ */
+declare function withInputSecret(secret: string): NgxTFormsFeature;
+
+/**
+ * Feeds {@link FormBuilderComponent} its `formId` from the activated route,
+ * preserving the historical route-driven form loading. Shipped by default in
+ * `provideNgxTForms`, so existing consumers see identical behaviour (D-B2 / §5.5);
+ * a router-free build resolves {@link FORM_ROUTE_SOURCE} to `EMPTY` and the
+ * builder loads from its `formId` input only.
+ *
+ * @example
+ *   provideNgxTForms(config, withRouterFormId())
+ *
+ * @public
+ */
+declare function withRouterFormId(): NgxTFormsFeature;
+
+/**
+ * Provides the action handlers (submit, save, cancel, etc.) that the forms
+ * runtime invokes when the user interacts with form controls. Bound from the
+ * `formActions` field of `NgxTFormsConfig` when the consumer calls
+ * `provideNgxTForms`.
+ *
+ * @see provideNgxTForms
+ */
+declare const FORM_ACTIONS_TOKEN: InjectionToken<IFormActions>;
+
+/**
+ * Provides the active `FormInterface` definition rendered by the forms
+ * runtime. Components downstream of the form host inject this token to read
+ * the form configuration without coupling to the store.
+ *
+ * @see provideNgxTForms
+ */
+declare const FORM_CONFIG_TOKEN: InjectionToken<FormInterface>;
+
+/**
+ * Provides the active `FormSlideInterface` (the slide/step currently being
+ * rendered). Scoped per slide by the form host so individual inputs can read
+ * their slide context.
+ *
+ * @see provideNgxTForms
+ */
+declare const FORM_SLIDES_TOKEN: InjectionToken<FormSlideInterface>;
+
+/**
+ * Provides the in-class utility object (`InClassFormUtilsInterface`) that
+ * exposes shared helper functions to form input components — formatting,
+ * validation helpers, and cross-input lookups.
+ *
+ * @see provideNgxTForms
+ */
+declare const UTILS_OBJECT_TOKEN: InjectionToken<InClassFormUtilsInterface>;
+
+/**
+ * Provides the merged form-input descriptor injected into each individual
+ * input element. The descriptor is an intersection of every supported input
+ * shape (`IWorkflowDocumentPicker & IBasicFormInput & IFileUploadInput &
+ * IDateRangePickerInput & ITextareaProperties & IToggleInput & IMatrixInput
+ * & IMultiple`) so a single token can describe any rendered input.
+ *
+ * @see provideNgxTForms
+ */
+declare const FORM_INPUTS_TOKEN: InjectionToken<IWorkflowDocumentPicker & IBasicFormInput & IFileUploadInput & IDateRangePickerInput & ITextareaProperties & IToggleInput & IMatrixInput & IMultiple>;
+
+/**
+ * Provides the `IMultiple` configuration to "multiple"-type inputs (inputs
+ * that produce an array of values). Scoped per input instance.
+ *
+ * @see provideNgxTForms
+ */
+declare const MULTIPLE_FORM_INPUT_TOKEN: InjectionToken<IMultiple>;
+
+/**
+ * Provides a factory function that returns an `Observable<IGetTreeResponse>`
+ * representing the MSCOA chart-of-accounts tree. Consumers bind this token
+ * to their backend lookup so MSCOA-aware inputs can lazily fetch the tree
+ * without depending on a concrete HTTP client.
+ *
+ * @see provideNgxTForms
+ */
+declare const MSCOA_TREE_PROVIDER: InjectionToken<() => Observable<IGetTreeResponse>>;
+
+/**
+ * Provides the top-level `NgxTFormsConfig` supplied by the consumer when
+ * calling `provideNgxTForms`. This is the root configuration token from
+ * which `formActions`, `formBuilder`, and other runtime concerns are read.
+ *
+ * @see provideNgxTForms
+ */
+declare const NGX_T_FORMS_CONFIG_TOKEN: InjectionToken<NgxTFormsConfig>;
+
+/**
+ * @public
+ *
+ * Abstract repository for MongoDB-aggregation-pipeline operations used by the
+ * library's pipeline-generator UI. The default HTTP-backed implementation is
+ * {@link HttpPipelineRepository}, bound by {@link withHttpPipeline}.
+ *
+ * Consumers may bind a custom implementation against
+ * {@link PIPELINE_REPOSITORY} (e.g. for offline / mocked environments) by
+ * providing an alternative `useClass` against the same token instead of (or
+ * after) `withHttpPipeline()`.
+ *
+ * Only the methods that cross the HTTP boundary are abstracted here; pipeline
+ * orchestration state (`pipeline$`, `chatHistory$`, etc.) remains inside the
+ * adapter / generator UI per LP §9 (the repository owns I/O, not UI state).
+ */
+declare abstract class PipelineRepository {
+    /**
+     * Execute the given aggregation pipeline against the configured backend for
+     * the supplied workflow.
+     *
+     * @param pipeline - Validated MongoDB aggregation stages to run.
+     * @param workflowId - Identifier of the workflow whose schema the pipeline
+     *   targets.
+     * @returns An observable that emits exactly one {@link IRunPipelineResponse}
+     *   then completes. Errors surface as a typed Error.
+     */
+    abstract runPipeline(pipeline: PipelineStage[], workflowId: string): Observable<IRunPipelineResponse>;
+    /**
+     * Ask the configured backend to generate (or refine) an aggregation pipeline
+     * from a natural-language query plus the workflow's document schema.
+     *
+     * @param query - The user's prompt.
+     * @param schema - Document schema the generator should target.
+     * @param threadId - Optional generator-session id (continues an in-flight
+     *   chat).
+     * @param existingPipeline - The pipeline-so-far, for incremental refinement.
+     * @param previousError - The last execution error to feed back into the
+     *   model, when applicable.
+     */
+    abstract generatePipeline(query: string, schema: object, threadId: string | undefined, existingPipeline: PipelineStage[], previousError: string): Observable<IPipelineGenerationResponse>;
+    /**
+     * Fetch the document schema for the supplied workflow.
+     *
+     * @param workflowId - Identifier of the workflow whose schema to load.
+     */
+    abstract getSchema(workflowId: string): Observable<{
+        schema: object;
+    }>;
 }
 
-declare const initFormConfigToV2: (formConfig: OLD_FormInterface) => FormInterface;
+/**
+ * @public
+ *
+ * Token binding the {@link PipelineRepository} abstraction. The default
+ * HTTP-backed implementation is {@link HttpPipelineRepository}, registered by
+ * {@link withHttpPipeline}. Consumers may substitute their own implementation
+ * by binding `useClass` (or `useValue` for a mock) against this token.
+ */
+declare const PIPELINE_REPOSITORY: InjectionToken<PipelineRepository>;
 
-declare function provideNgxTForms(config: NgxTFormsConfig): EnvironmentProviders;
+/**
+ * Secret used to derive per-input HMAC keys for client-side encryption of
+ * sensitive form values (currently: signature input payloads).
+ *
+ * Consumers MUST configure this via {@link withInputSecret} when the
+ * signature input is in use. The library does not ship a default — hardcoding
+ * a secret inside a published library would render it public.
+ *
+ * Treat the value as opaque, high-entropy, and never derived from anything
+ * the browser can read (e.g. `environment.ts` baked into the bundle is
+ * acceptable for low-sensitivity rotation; HSM-backed values are better).
+ *
+ * @see withInputSecret
+ */
+declare const INPUT_SECRET_TOKEN: InjectionToken<string>;
 
 /**
- * Generates a hierarchical form with nested FormGroups based on section IDs.
- * Parent form listens to all descendant changes, with validation cascading upward.
+ * Optional source of the form id to load into {@link FormBuilderComponent}.
  *
- * @param inputs Array of form inputs with their configurations
- * @param getFormValue Record of form values used for custom validation
- * @returns A FormGroup with nested FormGroups for each section
+ * Bound by `withRouterFormId()` (shipped by default in `provideNgxTForms`) to the
+ * activated route's `formId` param. When unbound — e.g. a router-free build — the
+ * builder loads from its `formId` input only. This decouples the builder from a
+ * direct `ActivatedRoute` dependency (plan D-B2 / §5.5).
+ *
+ * @public
  */
-declare function formGenerator(inputs: Array<FormColumnInputs>, getFormValue: () => Record<string, any>): FormGroup;
+declare const FORM_ROUTE_SOURCE: InjectionToken<Observable<string | undefined>>;
 
-interface IFormTour extends IStepOption {
-    sectionId: string;
+/**
+ * @public
+ *
+ * Default HTTP-backed implementation of {@link PipelineRepository}. Bound by
+ * {@link withHttpPipeline}; consumers needing a different transport should
+ * provide their own implementation against {@link PIPELINE_REPOSITORY}.
+ *
+ * The endpoint host (`http://localhost:5000`) is preserved from the pre-Phase-2
+ * `PipelineService` for I-1 parity. Configurable endpoints are tracked for a
+ * later phase — do not widen this surface ad-hoc.
+ */
+declare class HttpPipelineRepository implements PipelineRepository {
+    #private;
+    runPipeline(pipeline: PipelineStage[], workflowId: string): Observable<IRunPipelineResponse>;
+    generatePipeline(query: string, schema: object, threadId: string | undefined, existingPipeline: PipelineStage[], previousError: string): Observable<IPipelineGenerationResponse>;
+    getSchema(workflowId: string): Observable<{
+        schema: object;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpPipelineRepository, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HttpPipelineRepository>;
 }
 
-declare enum FunctionTypes {
-    ValueCalculation = "ValueCalculation",
-    ValuePostMethodAPI = "ValuePostMethodAPI",
-    ValuePostMethodAPIWithAllDefaultParams = "ValuePostMethodAPIWithAllDefaultParams",
-    OptionsPostMethodAPI = "OptionsPostMethodAPI",
-    OptionsPostMethodAPIWithAllDefaultParams = "OptionsPostMethodAPIWithAllDefaultParams",
-    ValueGetMethodAPI = "ValueGetMethodAPI",
-    OptionsGetMethodAPI = "OptionsGetMethodAPI",
-    InputSourcedValue = "InputSourcedValue",
-    ManualValueValidation = "ManualValueValidation"
+/**
+ * Renders the list of forms a user can open, edit, or build, with search,
+ * grouping (system vs custom), and section switching (active / archived /
+ * deleted) wired through the consumer-supplied `formBuilder` config.
+ *
+ * @remarks
+ * The component reads its data from `FormsStoreService` (provided locally)
+ * and reads the consumer's `NgxTFormsConfig` from {@link NGX_T_FORMS_CONFIG_TOKEN}
+ * to discover the close-button template and form CRUD callbacks
+ * (`editForm`, `addNewForm`).
+ *
+ * Inputs:
+ *  - _None._ The component is driven entirely by the activated route and
+ *    the injected forms store.
+ *
+ * Outputs:
+ *  - _None._ User intents (archive / unarchive / delete / edit / add) are
+ *    delegated to the store and to the consumer's `formBuilder` config.
+ */
+declare class FormsComponent implements OnInit {
+    #private;
+    selectFormsList$: Observable<LocalFormStateSelectorInterface[]>;
+    selectGroupedForms$: Observable<Record<string, LocalFormStateSelectorInterface[]>>;
+    searchQuery$: Observable<string>;
+    selectHasActiveSearch$: Observable<boolean>;
+    selectFilteredGroupedForms$: Observable<Record<string, LocalFormStateSelectorInterface[]>>;
+    selectLoadingForms$: Observable<boolean>;
+    selectErrors$: FormsStoreSelectorsInterface['selectErrors$'];
+    selectFormListSection$: Observable<FormListSection>;
+    NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
+    closeButton: ngx_t_forms_types.ActionButton;
+    get formListSections(): Array<{
+        value: FormListSection;
+        label: string;
+    }>;
+    viewportWidth: number;
+    ngOnInit(): void;
+    labels: {
+        label: string;
+        formControlName: string;
+    }[];
+    activeForm: string | null;
+    getCols(): number;
+    getFormAvatar(formTitle: string): string;
+    archive(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
+    unarchive(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
+    delete(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
+    loadForms(): void;
+    router: Router;
+    activatedRoute: ActivatedRoute;
+    setSection(value: FormListSection): void;
+    editForm(form: LocalFormStateSelectorInterface): void;
+    addNewForm(): void;
+    clearSearch(): void;
+    get searchQuery(): string;
+    set searchQuery(v: string);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormsComponent, "lib-forms, app-forms", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Editor surface for authoring a form definition — sections, steps, and
+ * the individual inputs in each step. Hosts the section stepper, input
+ * editor, builder menu, and missing-config diagnostics.
+ *
+ * @remarks
+ * The component reads its state and effects from a locally provided
+ * `FormsStoreService` and pulls the consumer-supplied close-button template
+ * from {@link NGX_T_FORMS_CONFIG_TOKEN}. Form loading is driven either by
+ * the `formId` input or by the activated route's `formId` param.
+ *
+ * Inputs:
+ *  - `formId: string` (optional) — when set, triggers `loadForm$` on the store.
+ *
+ * Outputs:
+ *  - _None._ All save/refresh intents are dispatched through the local store.
+ *
+ * @public
+ * @deprecated Migrating to the strict library mandates. Public surface is
+ * preserved verbatim; internal authoring is being refactored.
+ */
+declare class FormBuilderComponent {
+    #private;
+    /** Form-load spinner. */
+    readonly selectLoadingForm: _angular_core.Signal<boolean>;
+    /** Builder busy (saving / mutating). */
+    readonly selectFormBuilderIsBusy: _angular_core.Signal<boolean>;
+    /** "Updated N days ago" label, or null. */
+    readonly selectFormUpdated: _angular_core.Signal<string | Date | null>;
+    /** Whether the current form passes validation and can be saved. */
+    readonly canSaveForm: _angular_core.Signal<boolean>;
+    /** Whether the form in edit is unsaved (no formId yet). */
+    readonly isNewForm: _angular_core.Signal<boolean>;
+    /** Optional form identifier. When set, triggers `loadForm$` on the local store. */
+    readonly formId: _angular_core.InputSignal<string | undefined>;
+    /** Whether a form id is present in the store. */
+    readonly selectHasFormId: _angular_core.Signal<boolean>;
+    /** Whether the form has missing/invalid configuration. */
+    readonly hasMissingConfigs: _angular_core.Signal<boolean>;
+    /** Whether an input editor panel is currently open. */
+    readonly elementEditorOpen: _angular_core.Signal<boolean>;
+    pendingExternalRefresh: _angular_core.Signal<{
+        form: ngx_t_forms_types.FormInterface;
+        timestamp: Date;
+    } | null>;
+    refreshCountdown: _angular_core.WritableSignal<number>;
+    constructor();
+    triggerRefreshNow(): void;
+    readonly NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
+    readonly closeButton: ngx_t_forms_types.ActionButton;
+    saveForm: () => void;
+    /** Editable form title — seeded from the store, overridable by local edits. */
+    protected readonly titleValue: _angular_core.WritableSignal<string>;
+    /** Pushes a title edit to the store (schedule-only refresh, matching `setFormTitle`). */
+    protected setTitleValue(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormBuilderComponent, "lib-form-builder, app-form-builder", never, { "formId": { "alias": "formId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Workflow function-type enum, upstreamed to `ngx-t-forms-types` as
+ * {@link WorkflowFunctionTypes} per DECISIONS.md D-016. Re-exported here under
+ * its historical name `FunctionTypes` to preserve every existing local import
+ * path (including the immutable `form-tower-controller.service.ts` per D-007).
+ *
+ * @public
+ */
+declare const FunctionTypes: typeof WorkflowFunctionTypes;
+type FunctionTypes = WorkflowFunctionTypes;
+
 declare enum HintType {
     WARNING = "warning",
     ERROR = "error",
@@ -80,54 +435,345 @@ declare enum HintType {
     DOCUMENT = "document",
     HISTORY = "history"
 }
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
 declare function textIconsForUserHints(hint: string, type: HintType): string;
 
-interface DependentInput {
+/**
+ * @file Pure helpers for the **overridable validation** submission gate.
+ *
+ * A custom validator declared with `canOverride === true` does not block
+ * submission outright. The gate distinguishes two error classes across the
+ * settled form:
+ *
+ * - **Blocking** — every error that is NOT an overridable custom-validator
+ *   error: standard validators (`required`, `email`, `minlength`, …), MSCOA
+ *   business-rule errors, and custom validators with `canOverride === false`.
+ *   These MUST be resolved before the form can be submitted.
+ * - **Overridable** — a custom-validator error whose value object carries
+ *   `canOverride === true`. The form may be submitted with these still failing
+ *   **provided each one is motivated** with a non-empty comment.
+ *
+ * The error-record shape these helpers read is produced verbatim by the
+ * {@link FunctionTypes.ManualValueValidation} builder
+ * (`build-manual-validation.ts`): `{ [validatorId]: { message, canOverride } }`,
+ * merged onto `control.errors` by the W11 projection adapter. A validator id is
+ * a uuid unique per `(input, validator)`, so it uniquely keys an override
+ * reason.
+ *
+ * All functions here are pure reads over the projected `FormGroup` tree and the
+ * tower's `allFormInputs()` index — no signal writes, no Angular runtime
+ * primitives created. They are safe to call from template getters during change
+ * detection (mirrors `getSubmissionStatus.ts`).
+ */
+
+/**
+ * A still-failing overridable custom validation surfaced to the override UI.
+ */
+interface OverridableError {
+    /** The custom validator's id — the `control.errors` key and the reason key. */
+    validatorId: string;
+    /** The owning input's id (its control name within the section group). */
     inputId: string;
-    functionType: FunctionTypes;
+    /** The owning input's `formControlName`, used to build the submission entry. */
+    formControlName: string;
+    /** The input's display label, for the override-reason prompt. */
+    label: string;
+    /** The validator's human-readable message. */
+    message: string;
+}
+/**
+ * A single captured override motivation, keyed in the engine by `validatorId`.
+ */
+interface OverrideReason {
+    /** User-supplied motivation. Must be non-empty (trimmed) to unlock submission. */
+    comment: string;
+    /** Optional supporting file, carried as base64 {@link FileData}. */
+    attachment?: FileData;
 }
+/** Map of `validatorId → captured reason`. The engine's override-reason state. */
+type OverrideReasons = Record<string, OverrideReason>;
+
+/**
+ * Core orchestrator for a runtime form (the "tower") — abstract because every
+ * concrete consumer (`TFormEngine`, the import row instance) extends it and
+ * Angular's DI provides {@link HttpClient} + {@link NGX_T_FORMS_CONFIG_TOKEN}.
+ *
+ * ### Lifecycle (Phase 1)
+ * 1. **{@link FormTowerControllerService.initialize}** — prepPopulate +
+ *    loadSystemInputs + formGenerator + setFirstStepAsActive, then builds the
+ *    per-input `#derived` signal graph (in injection context) and wires the
+ *    FormGroup-projection + persist effects. There is NO `valueChanges`
+ *    subscription and NO dependency-graph build.
+ * 2. **{@link FormTowerControllerService.initializeFormValues}** — writes
+ *    user/import values into `#model` (tower-owned derived inputs are skipped
+ *    structurally) and forces a liveness lead-read so lazy resources start.
+ * 3. User interaction / `updateValue` → writes `#model` (or a sourced
+ *    `linkedSignal.set`) → derived signals + resources recompute automatically.
+ * 4. **{@link FormTowerControllerService.waitUntilSettled}** — used by headless
+ *    consumers (import) to wait for all in-flight async work to drain.
+ * 5. **{@link FormTowerControllerService.ngOnDestroy}** — explicitly destroys
+ *    every resource, the projection/persist effects, the `isBusy$`
+ *    subscription, and clears hint/error timers.
+ *
+ * ### Why an abstract `@Directive()`?
+ * Angular requires the `@Directive()` decorator on classes that participate in
+ * DI inheritance + `OnDestroy`. Subclasses can be plain `@Injectable()` (see
+ * {@link TFormEngine}).
+ */
 declare abstract class FormTowerControllerService implements OnDestroy {
+    #private;
     private _http;
+    /** Resolved tower config (HTTP functions, file upload, getFinacialCycles, …). */
     readonly NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
+    /** Convenience pass-through to the financial-cycles fetcher from config. */
     readonly getFinacialCycles: () => Observable<ngx_t_forms_types.IFinancialCycles>;
     constructor(_http: HttpClient);
+    /** Emits exactly once on tower destruction. `takeUntil` anchor for long-lived subscriptions. */
     protected _destroyed$: Subject<void>;
-    protected _form: FormInterface | undefined;
+    /** Live root `FormGroup` — the Material carrier (Blueprint §2.7). Built by `formGenerator`. */
     protected _mainForm: FormGroup | undefined;
-    protected _formValue: Record<string, any>;
+    /** The values record last passed to {@link FormTowerControllerService.initializeFormValues}. */
     protected _initialFormValue: Record<string, any>;
-    protected _systemInputs: FormColumnInputs[];
-    protected _inputFunctionsCollection: Record<string, Partial<Record<FunctionTypes, Observable<void>>>>;
-    protected _inputChangeDependencyRecords: Partial<Record<string, Partial<Record<FunctionTypes, Record<string, boolean>>>>>;
-    protected _reverseDependencyMap: Record<string, DependentInput[]>;
-    protected _changeHistory: IFormChangeHistory[];
+    /** Last reported submission state — drives the toolbar/spinner UI. */
     submittingStatus: FormSubmissionStatus | undefined;
-    submittingForm: boolean;
+    /** True while a form submission is in flight. Counts toward {@link FormTowerControllerService.isBusy}. */
+    get submittingForm(): boolean;
+    set submittingForm(value: boolean);
+    /**
+     * The still-failing overridable (`canOverride === true`) validations on the
+     * settled form, one per failing validator, each carrying the input's
+     * `formControlName` / `label` and the validator message — the data the
+     * override-reason UI renders a motivation prompt from.
+     *
+     * Reads the projected control tree, so it reflects the latest validity. When
+     * there are blocking errors as well, those still prevent submission — see
+     * {@link FormTowerControllerService.canSubmit}.
+     */
+    overridableErrors: () => OverridableError[];
+    /**
+     * `true` when at least one blocking (non-overridable) error remains on the
+     * form. While this holds, submission is impossible regardless of motivations.
+     */
+    hasBlockingErrors: () => boolean;
+    /**
+     * Whether the form may be submitted: no blocking errors AND every overridable
+     * error has a non-empty motivation. Replaces the blunt `mainForm.invalid`
+     * submit gate — an overridable error with a reason no longer blocks.
+     */
+    canSubmit: () => boolean;
+    /** The currently captured override motivations, keyed by validator id. */
+    get overrideReasons(): OverrideReasons;
+    /**
+     * Records (or updates) the motivation comment for one overridable validation.
+     *
+     * @param validatorId - The validator's id (the `control.errors` key).
+     * @param comment     - The user's motivation; an empty/whitespace value
+     *   re-locks submission for that error.
+     */
+    setOverrideComment: (validatorId: string, comment: string) => void;
+    /**
+     * Attaches (or clears) a supporting file for one overridable validation.
+     *
+     * @param validatorId - The validator's id (the `control.errors` key).
+     * @param attachment  - The base64 {@link FileData}, or `undefined` to clear.
+     */
+    setOverrideAttachment: (validatorId: string, attachment: FileData | undefined) => void;
+    /**
+     * Drops the captured reasons for the given validator ids. Called once a
+     * MultipleInput sub-row is saved — its motivations move from the live
+     * reason map into {@link FormTowerControllerService.#rowOverrides}, and the
+     * transient controls (and thus the live overridable errors) are removed.
+     *
+     * @param validatorIds - The validator ids whose live reasons to drop.
+     */
+    clearOverrideReasons: (validatorIds: readonly string[]) => void;
+    /**
+     * Records (or clears) the captured override entries for one MultipleInput
+     * sub-row. Replacing on every save keeps a re-edited row's motivations
+     * current; passing an empty list removes the row's entry.
+     *
+     * @param inputId - The MultipleInput's id.
+     * @param rowId   - The sub-row's id (`${inputId}.id` value).
+     * @param entries - The override entries captured for the row.
+     */
+    setRowOverrides: (inputId: string, rowId: string, entries: IFormValidationOverride[]) => void;
+    /**
+     * Builds the override entries for the currently-open inner inputs of a
+     * MultipleInput sub-row, pairing each overridable error with its captured
+     * motivation. Returns the entries plus the validator ids consumed (so the
+     * caller can move them out of the live reason map after the row is saved).
+     *
+     * @param inputId     - The MultipleInput's id.
+     * @param innerInputs - The sub-row's inner inputs (composite-id form inputs).
+     * @returns The sub-row's override state: motivated `entries` ready to persist,
+     *   the `validatorIds` consumed, and the inner input ids that are blocking or
+     *   still unmotivated (for save-gate messaging).
+     */
+    collectRowOverrideState: (inputId: string, innerInputs: FormColumnInputs[]) => {
+        entries: IFormValidationOverride[];
+        validatorIds: string[];
+        blockingInputIds: string[];
+        unmotivatedInputIds: string[];
+    };
+    /** The current form definition (post-{@link prepPopulateForm}). */
     get form(): FormInterface | undefined;
     set form(value: FormInterface | undefined);
-    set systemInputs(value: FormColumnInputs[]);
+    /** System inputs loaded by `loadSystemInputs`, prepended to {@link FormTowerControllerService.allFormInputs}. */
     get systemInputs(): FormColumnInputs[];
+    set systemInputs(value: FormColumnInputs[]);
+    /** Live root `FormGroup` — `undefined` before {@link FormTowerControllerService.initialize}. */
     get mainForm(): FormGroup | undefined;
+    /** Append-only change history; used by {@link FormTowerControllerService.revertBackHistory}. */
     get changeHistory(): IFormChangeHistory[];
     set changeHistory(value: IFormChangeHistory[]);
-    get inputFunctionsCollection(): Record<string, Partial<Record<FunctionTypes, Observable<void>>>>;
+    /**
+     * Busy iff a submission is in flight OR any value/options resource is
+     * `'loading'`. Reading every resource's `status()` here is what ACTIVATES the
+     * lazy resources — workers MUST NOT short-circuit before iterating
+     * (resource-activation contract, Blueprint §2.4 / HAZARD 2).
+     */
+    protected readonly isBusyComputed: Signal<boolean>;
+    /** Strict complement of {@link FormTowerControllerService.isBusyComputed}. */
+    protected readonly settled: Signal<boolean>;
+    /** Synchronous snapshot of the busy state. */
+    get isBusy(): boolean;
+    /**
+     * Reactive stream of the tower's busy state. Emits `true` while any
+     * calculation/API/validation is in flight or the form is submitting, `false`
+     * once everything settles. Backed by `toObservable(isBusy)`.
+     */
+    get isBusy$(): Observable<boolean>;
+    /**
+     * Resolves once the tower has finished all in-flight async work (calculations,
+     * API fetches, sourced values). Used by headless consumers (import).
+     *
+     * **Contract (Blueprint §5 / §6, never changes):**
+     * - Performs a one-tick liveness lead-read FIRST (reads `value()` + every
+     *   resource `status()` + flushes effects) so lazy resources start even when
+     *   no template reads them (HAZARD 2).
+     * - Waits for the first `settled() === true` emission.
+     * - On `timeoutMs` it resolves with `undefined` — it NEVER rejects and NEVER
+     *   hangs (`timeout` + `defaultIfEmpty`-equivalent via `catchError`).
+     *
+     * @param debounceMs - Accepted for signature parity; the signal graph needs no
+     *   debounce, so it is treated as a no-op lead time.
+     * @param timeoutMs - Hard timeout before resolving with `undefined` (default 30s).
+     * @returns A promise that always resolves (with `void`).
+     */
+    waitUntilSettled(debounceMs?: number, timeoutMs?: number): Promise<void>;
+    /**
+     * Tears the tower down. Fires `_destroyed$`, runs
+     * {@link FormTowerControllerService.clearFormState} (which destroys resources
+     * + effects), completes the `isBusy$` subscription, and clears pending
+     * hint/error timers (HAZARD 7 / Blueprint §2.8).
+     */
     ngOnDestroy(): void;
-    initialize: (form: FormInterface) => Promise<void>;
+    /**
+     * Boots the tower against a form definition.
+     *
+     * Performs, in order:
+     * 1. {@link FormTowerControllerService.clearFormState} — wipe prior state +
+     *    destroy any prior resources/effects.
+     * 2. {@link prepPopulateForm} — merge `_initialFormValue` into the columns.
+     * 3. {@link loadSystemInputs} — load financial cycle, current user, etc.
+     * 4. {@link formGenerator} — build the nested `FormGroup` carrier.
+     * 5. Re-open any `MultipleInput` that was open before re-init.
+     * 6. Build the `#derived` signal graph + wire the projection/persist effects
+     *    — ALL inside `runInInjectionContext(this.#injector, …)` (HAZARD 1).
+     *
+     * @param form - The form definition to drive.
+     * @param options - Optional behaviour flags.
+     * @param options.skipInitialFunctions - **Documented no-op (parity).** The
+     *   old engine used this to suppress a premature change-monitor cycle in the
+     *   headless import path. The signal graph has no such race (resources fire
+     *   lazily once read; the liveness lead-read in
+     *   {@link FormTowerControllerService.initializeFormValues} +
+     *   {@link FormTowerControllerService.waitUntilSettled} activates them), so
+     *   the flag is accepted for signature parity and otherwise ignored.
+     */
+    initialize: (form: FormInterface, options?: {
+        skipInitialFunctions?: boolean;
+    }) => Promise<void>;
+    /**
+     * Marks the form's first slide as active. Called during
+     * {@link FormTowerControllerService.initialize}.
+     */
     setFirstStepAsActive: () => void;
+    /**
+     * Returns the form's settled values keyed by **formControlName** (the
+     * canonical external shape). Reads {@link FormTowerControllerService.value}.
+     */
     getFormValueNames: () => Record<string, any>;
+    /**
+     * All form inputs that participate in the form, including system inputs.
+     * Returns a fresh outer array each call (preserves the prior contract that
+     * callers may mutate the returned array), but the expensive flatten beneath it
+     * is memoized by {@link FormTowerControllerService.#allInputsMemo}.
+     */
     readonly allFormInputs: () => FormColumnInputs[];
+    /** @deprecated unused field, kept for backwards compatibility. */
     prevValue: any;
-    protected changeMonitor: (newFormValue: any) => Observable<any>;
-    createInputFunctionsCollection: () => void;
-    private buildReverseDependencyMap;
-    createAllInputDependencies: () => void;
+    /**
+     * Mark a logical operation in flight for DOM badge rendering. Phase 1: no
+     * longer affects {@link FormTowerControllerService.isBusy} (busy is
+     * resource-derived) — forwards to the DOM-status helper only.
+     */
     setInputStatus: (inputId: string, statusId: string, status: string) => void;
+    /** Companion to {@link FormTowerControllerService.setInputStatus} — clears the DOM badge. */
     removeInputStatus: (inputId: string, statusId: string) => void;
+    /**
+     * Programmatic write to a form input.
+     *
+     * - **Sourced inputs** (InputSourcedValue) → routes to the entry's writable
+     *   `linkedSignal.set(value)` (transient override; reset on next source change).
+     * - **All other inputs** → writes `#model[inputId]`.
+     *
+     * Appends the change to history IMPERATIVELY (HAZARD 4). The projection effect
+     * patches the FormControl from the signal graph — this does NOT touch the
+     * FormGroup directly (no `valueChanges` feedback loop).
+     *
+     * @param inputId - The input to write.
+     * @param value - The new value.
+     */
     updateValue: (inputId: string, value: any) => void;
-    getFunctionByType(fn: FunctionTypes, input: FormColumnInputs): Observable<void>;
+    /**
+     * Apply an external values record onto the form (user prefill / import row).
+     *
+     * Per input:
+     * - **Tower-owned non-MultipleInput** (calc/API/sourced) → SKIP structurally
+     *   (it never enters `#model`; the derived signal/resource owns the value).
+     * - **MultipleInput** → ALWAYS apply the row array (its rows are user-authored
+     *   source data). The array-remap branch is UNCHANGED (Phase 2 fence).
+     * - **Everything else** → write `#model` from the dotted-path or top-level value.
+     *
+     * Ends with a liveness lead-read so lazy resources start even in the headless
+     * import path (no template reader) — HAZARD 2 / Blueprint §2.7.
+     *
+     * @param initialValues - The external values record (formControlName-keyed).
+     */
+    initializeFormValues: (initialValues: Record<string, any>) => void;
+    /**
+     * Snapshot of the inputId-keyed flat form value. Re-points to the merged
+     * {@link FormTowerControllerService.value} computed (was the old `_formValue`).
+     * Passed to legacy helpers (refresh) that expect a `() => Record` accessor.
+     */
     getFormValue: () => Record<string, any>;
+    /**
+     * Resets all internal state — definition, FormGroup, signal graph (resources +
+     * effects destroyed), busy/model/history — so the tower can be re-initialized.
+     * Called at the start of {@link FormTowerControllerService.initialize} and from
+     * {@link FormTowerControllerService.ngOnDestroy}.
+     *
+     * Explicitly `.destroy()`s every `ResourceRef` and the projection/persist
+     * effects (HAZARD 7 / Blueprint §2.8 — per-row import towers are torn down by
+     * manual `ngOnDestroy`, not injector destruction).
+     */
     clearFormState: () => void;
-    executeInputFunctionsWithoutDependencies: () => void;
     _hintTimeoutIds: Record<string, any>;
     setTemporaryHint: (inputId: string, hint: string, type: HintType) => void;
     _onFormInputConfigChange?: (inputId: string, config: FormColumnInputs) => void;
@@ -140,489 +786,362 @@ declare abstract class FormTowerControllerService implements OnDestroy {
     updateFormInputConfig: (inputId: string, config: FormColumnInputs) => void;
     handleStepChange: (event: StepperSelectionEvent) => void;
     selectFormSteps: () => ngx_t_forms_types.ITowerFormSteps[];
-    selectAllFormTours: () => IFormTour[];
+    selectAllFormTours: () => ngx_t_forms_types.IFormTour[];
     setSectionAsSeen: (sectionId: string) => void;
     setSectionAsActive: (sectionId: string) => void;
     setInputAsTouchedAndDirty: (inputId: string) => void;
     formProgress: () => number;
     formSubmissionMessage: () => string;
     setSubmissionStatusValue: (status: FormSubmissionStatus) => FormSubmissionStatus;
-    initializeFormValues: (initialValues: Record<string, any>) => void;
-    reset(): void;
-    revertBackHistory: () => void;
     /**
-     * Form Submissions
+     * Legacy-shaped per-input function registry, reconstructed from `#derived`
+     * (Decision D3). Each present `(inputId, functionType)` maps to an
+     * `Observable<void>` that, on subscription, drives the underlying primitive:
+     * - resource/options entries → `.reload()` then complete when status leaves
+     *   `'loading'`;
+     * - value/sourced/validation entries → a synchronous read then complete.
+     *
+     * Kept so `refreshInputWithDependencies` / `refreshInput` /
+     * `runMultipleInputPrepopulationFunctions` / `getTopologicalExecutionOrder`
+     * compile + behave unchanged. The return TYPE is unchanged (api:check parity).
      */
-    submitForm: (passData: Record<string, any>) => void;
+    get inputFunctionsCollection(): Record<string, Partial<Record<FunctionTypes, Observable<void>>>>;
     /**
-     * Toggles a multiple input element and its associated form controls.
-     * When toggled on, adds controls to the form. When toggled off, removes them.
+     * Submits the form to the configured backend pipeline. Builds a payload by
+     * un-flattening the settled values, delegates to {@link formHttpSubmissions},
+     * and reports status. Errors surface as `FormSubmissionStatus.FAILED` — they
+     * do not throw to the caller.
      *
-     * @param inputId The ID of the multiple input to toggle
-     * @returns boolean indicating success or failure
+     * @param passData - Extra context handed through to the submission pipeline.
      */
+    submitForm: (passData: Record<string, any>) => void;
+    /** Toggle a MultipleInput element + its associated form controls. */
     toggleMultipleInput: (inputId: string, open: boolean, rowInEditId?: string) => boolean;
+    /** Persist the open MultipleInput sub-form back into the parent control's array value. */
     saveMultipleInputForm: (inputId: string) => boolean;
+    /** Open the MultipleInput sub-form prepopulated with `rowId`'s values. */
     multipleInputEditRow: (inputId: string, rowId: string) => boolean;
+    /** Duplicate `rowId` and open the sub-form on the new row. */
     multipleInputDuplicateRow: (inputId: string, rowId: string) => boolean;
-    refreshSection: (sectionId: string) => Observable<void>;
+    /**
+     * Bridges live edits of an OPEN MultipleInput sub-row into the signal graph.
+     *
+     * Subscribes every sub-row control (`${inputId}.${childId}`) — except the
+     * `${inputId}.id` row-bookkeeping control — to `updateValue(controlName, …)`,
+     * so a sub-row field behaves exactly like a primary-form input: dependent
+     * calculations / value-fetches / validators (whether they live in the same
+     * row or in the primary form) re-fire the moment a dependency changes.
+     *
+     * Idempotent per `inputId` (re-binding tears down the prior subscription
+     * first). Each inner subscription is `takeUntil(this._destroyed$)`-anchored so
+     * a re-init also drops it. Called by `toggleMultipleInput` on open; mirrored
+     * by {@link FormTowerControllerService.unbindMultipleInputRowControls} on close.
+     *
+     * @param inputId - The MultipleInput whose open sub-row controls to bridge.
+     */
+    bindMultipleInputRowControls: (inputId: string) => void;
+    /**
+     * Tears down the live sub-row `valueChanges` bridge wired by
+     * {@link FormTowerControllerService.bindMultipleInputRowControls}. Called by
+     * `toggleMultipleInput` on close (and implicitly on re-open / re-init).
+     *
+     * @param inputId - The MultipleInput whose sub-row bridge to drop.
+     */
+    unbindMultipleInputRowControls: (inputId: string) => void;
+    /**
+     * Re-runs every refreshable function for inputs in `sectionId` (resource
+     * `.reload()` + dependency order). Returns an Observable that completes when
+     * the section's refresh chain drains.
+     *
+     * @param sectionId - The section to refresh.
+     * @returns An Observable completing when the section is refreshed.
+     */
+    refreshSection: (sectionId: string) => Observable<any>;
+    /**
+     * Fire-and-forget refresh of whichever slide is currently active. Returns
+     * `void` (parity — the consumer-map row claiming `Observable<any>` is wrong).
+     */
     refreshActiveSection: () => void;
-    refreshInput: (inputId: string) => Observable<undefined>;
+    /**
+     * Refresh a single input plus everything it transitively depends on.
+     *
+     * @param inputId - The input to refresh.
+     * @returns An Observable completing when the refresh drains.
+     */
+    refreshInput: (inputId: string) => Observable<void>;
+    /** True iff the input has at least one refreshable `#derived` entry. */
     canRefreshFn: (inputId: string) => boolean;
+    /**
+     * True iff any input in the section is refreshable. The HTML refresh-button
+     * gate (`user-form-stepper.component.html`) depends on this exact truth value
+     * (Blueprint §4 / W13).
+     */
     canRefreshSection: (sectionId: string) => boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormTowerControllerService, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FormTowerControllerService, never, never, {}, {}, never, never, true, never>;
-}
-
-declare function getSectionElements(elements: ElementEditorInnerSectionElementInterface[], inputInEdit: (FormColumnInputs) | undefined, NGX_T_FORMS_CONFIG: NgxTFormsConfig, utils: InClassFormUtilsInterface, errors?: ValidationError[]): (never[] | {
-    computedErrors: ValidationError[];
-    required: boolean;
-    postmanCollectionConfig: {
-        collectionUrl: string;
-        collectionKey: string;
-    } | undefined;
-    httpGetDataFunction: (url: string, options: any) => rxjs.Observable<any>;
-    getWorkflowOptions: rxjs.Observable<ngx_t_forms_types.IWorkflowOption[]>;
-    getMscoaTree: rxjs.Observable<ngx_t_forms_types.IGetTreeResponse> | undefined;
-    id: string;
-    name: FormInputKeys | SpecialElementKeys | AllFormInputPrimaryKeys;
-    hint?: string;
-    editType: ElementEditorTypes;
-    deepBind: Array<string>;
-    defaultValue?: any;
-    limitTo?: number;
-    additionalTest?: ngx_t_forms_types.ConfigurationValidTestInterface[];
-    disabled?: ngx_t_forms_types.ConfigurationValidTestInterface[];
-    fetchOptions?: string[];
-    secondaryElementEditorConfig?: Array<ngx_t_forms_types.ElementEditorConfigSectionInterface>;
-    clearOnChange?: string[][];
-    blurHandle?: ngx_t_forms_types.BlurHandleTypes;
-    label: string;
-    readonly?: boolean;
-    templateOptions?: Array<any>;
-    placeholder?: string;
-    options?: Array<{
-        label: string;
-        value: any;
-    }>;
-    min?: number;
-    max?: number;
-    step?: number;
-    format?: (value: any) => number;
-})[];
-
-declare const returnMappedPathValue: (pathMap: TreeNode[], obj: any) => any;
-declare const getValueFromValueAccessor: (valueAccessRules: FormInputBasicOptionInterface | TreeNode[] | Record<string, TreeNode[]>, data: any) => any;
-
-declare const FORM_ACTIONS_TOKEN: InjectionToken<IFormActions>;
-declare const FORM_CONFIG_TOKEN: InjectionToken<FormInterface>;
-declare const FORM_SLIDES_TOKEN: InjectionToken<FormSlideInterface>;
-declare const UTILS_OBJECT_TOKEN: InjectionToken<InClassFormUtilsInterface>;
-declare const FORM_INPUTS_TOKEN: InjectionToken<IWorkflowDocumentPicker & IBasicFormInput & IFileUploadInput & IDateRangePickerInput & ITextareaProperties & IToggleInput & IMatrixInput & IMultiple>;
-declare const MULTIPLE_FORM_INPUT_TOKEN: InjectionToken<IMultiple>;
-declare const MSCOA_TREE_PROVIDER: InjectionToken<() => Observable<IGetTreeResponse>>;
-declare const NGX_T_FORMS_CONFIG_TOKEN: InjectionToken<NgxTFormsConfig>;
-
-declare class DialogTemplateComponent {
-    readonly dialogRef: MatDialogRef<any, any>;
-    readonly data: DialogConfig;
-    proceed(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTemplateComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DialogTemplateComponent, "lib-dialog-template", never, {}, {}, never, never, true, never>;
+    /**
+     * Pop the last change-history entry and re-apply the PRIOR snapshot via
+     * {@link FormTowerControllerService.updateValue} (restores to second-to-last,
+     * matching the old semantics exactly). Decorates each restored input with a
+     * transient hint. History append stays imperative (HAZARD 4).
+     */
+    revertBackHistory: () => void;
+    /**
+     * Hard reset: tear down current state and re-initialize from the same form
+     * definition + originally supplied values.
+     *
+     * **D4 (deliberate, signed-off):** AWAITS `initialize(form)` BEFORE calling
+     * `initializeFormValues(...)`, fixing the old unawaited mis-ordering where
+     * `initializeFormValues` could run before `_mainForm` was rebuilt. The public
+     * signature is unchanged.
+     */
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormTowerControllerService, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormTowerControllerService, never, never, {}, {}, never, never, true, never>;
 }
 
-declare class FormBuilderComponent implements OnDestroy, OnInit {
-    subscription$: Subscription;
-    private store;
-    private route;
-    selectLoadingForm: i0.Signal<boolean>;
-    selectFormBuilderIsBusy: i0.Signal<boolean>;
-    selectFormUpdated: i0.Signal<string | Date | null>;
-    canSaveForm: i0.Signal<boolean>;
-    isNewForm: i0.Signal<boolean>;
-    set formId(value: string);
-    selectHasFormId: i0.Signal<boolean>;
-    hasMissingConfigs: i0.Signal<boolean>;
-    elementEditorOpen: i0.Signal<boolean | null>;
-    constructor();
-    readonly NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
-    readonly closeButton: ngx_t_forms_types.ActionButton;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    saveForm: () => void;
-    _title: string;
-    set titleValue(value: string);
-    initiatedTitle: boolean;
-    get titleValue(): string | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormBuilderComponent, "app-form-builder", never, { "formId": { "alias": "formId"; "required": false; }; }, {}, never, never, true, never>;
+/**
+ * Per-component runtime form engine.
+ *
+ * `TFormEngine` is the **composition seam** introduced by SIGNAL_FORMS migration
+ * Phase 0 (see `docs/migration/SIGNAL_FORMS_MIGRATION_PLAN.md` §5.1/§6.0 and
+ * DECISIONS.md D-023/D-025). Consumers previously **extended**
+ * {@link FormTowerControllerService} directly; they now **hold** a `TFormEngine`
+ * instance via `inject(TFormEngine)` (provided per-component, not
+ * `providedIn: 'root'`) and reach the tower's surface through it.
+ *
+ * Phase 0 moves **no logic**: this façade is a thin subclass of the existing
+ * tower so the full member surface is preserved verbatim and consumer behaviour
+ * stays under the I-1 Parity invariant. Phase 1 will rewrite the tower internals
+ * behind this same façade without touching the three consumers again.
+ *
+ * Internal to the library — not part of the public API. Provide it on the
+ * component that needs it:
+ *
+ * @example
+ *   @Component({
+ *     // …
+ *     providers: [TFormEngine],
+ *   })
+ *   export class UserFormStepperComponent {
+ *     protected readonly engine = inject(TFormEngine);
+ *   }
+ */
+declare class TFormEngine extends FormTowerControllerService {
+    constructor(http: HttpClient);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TFormEngine, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TFormEngine>;
 }
 
-declare class FormsStoreService extends ComponentStore<IFormsInitStateInterface> {
-    httpClient: HttpClient;
-    snackBar: MatSnackBar;
-    sectionPlaceholder: Record<string, AbstractControl>;
-    readonly NGX_T_FORMS_CONFIG: NgxTFormsConfig;
+declare class TourManagerService {
+    private readonly tourService;
+    userProfile: this;
     constructor();
-    utils: InClassFormUtilsInterface;
-    showMessage(message: string, type: HintType): void;
-    private setupDevTools;
-    get resourceFunctions(): IStoreFunctions | null;
-    readonly selectors: FormsStoreSelectorsInterface;
-    readonly formBuilderSelectors: {
-        selectFormSlides$: Observable<ngx_t_forms_types.FormSlideInterface[]>;
-        missingConfig$: Observable<string[]>;
-        canSaveForm$: Observable<boolean>;
-        isNewForm$: Observable<boolean>;
-        hasMissingConfigs$: Observable<boolean>;
-        formErrors$: Observable<{
-            key: string;
-            message: string;
-        }[]>;
-        formValidationErrorsMessages$: Observable<string[]>;
-        inputInEdit$: Observable<ngx_t_forms_types.FormColumnInputs | undefined>;
-        defaultInputInEdit$: Observable<any>;
-        inputInEditValidationErrors$: Observable<ngx_t_forms_types.ValidationError[]>;
-        selectFormTitle$: Observable<string | undefined>;
-        getAllFormInputs$: Observable<never[] | ngx_t_forms_types.FormColumnInputs[]>;
-        inputElementEditorConfigs$: Observable<{
-            editorSections: {
-                elements: {
-                    editType: ngx_t_forms_types.ElementEditorTypes;
-                    id: string;
-                    name: ngx_t_forms_types.FormInputKeys | ngx_t_forms_types.SpecialElementKeys | ngx_t_forms_types.AllFormInputPrimaryKeys;
-                    hint?: string;
-                    deepBind: Array<string>;
-                    defaultValue?: any;
-                    limitTo?: number;
-                    additionalTest?: ngx_t_forms_types.ConfigurationValidTestInterface[];
-                    disabled?: ngx_t_forms_types.ConfigurationValidTestInterface[];
-                    fetchOptions?: string[];
-                    secondaryElementEditorConfig?: Array<ngx_t_forms_types.ElementEditorConfigSectionInterface>;
-                    clearOnChange?: string[][];
-                    blurHandle?: ngx_t_forms_types.BlurHandleTypes;
-                    label: string;
-                    required?: boolean;
-                    readonly?: boolean;
-                    templateOptions?: Array<any>;
-                    placeholder?: string;
-                    options?: Array<{
-                        label: string;
-                        value: any;
-                    }>;
-                    computedErrors?: ngx_t_forms_types.ValidationError[];
-                    min?: number;
-                    max?: number;
-                    step?: number;
-                    format?: (value: any) => number;
-                    postmanCollectionConfig?: ngx_t_forms_types.IPostmanCollectionConfig;
-                    httpGetDataFunction?: (url: string, options: any) => Observable<any>;
-                    getWorkflowOptions?: Observable<ngx_t_forms_types.IWorkflowOption[]> | undefined;
-                    getMscoaTree?: Observable<ngx_t_forms_types.IGetTreeResponse> | undefined;
-                }[];
-                hasErrors: boolean;
-                label: string;
-                showItemValue?: keyof ngx_t_forms_types.FormColumnInputs;
-                id: string;
-                additionalTest?: ngx_t_forms_types.ConfigurationValidTestInterface[];
-            }[];
-            title?: string;
-            description?: string;
-        }>;
-        selectFormSlideSections$: Observable<{
-            inputConfigErrors: {
-                key: string;
-                message: string;
-            }[];
-            sectionId: string;
-            label: string;
-            columns: Array<ngx_t_forms_types.FormColumnInputs>;
-            inEdit?: boolean;
-            sectionIsSeen?: boolean;
-            isActive?: boolean;
-        }[]>;
-    };
-    readonly actions: {
-        loadFormListSuccess: (observableOrValue: {
-            forms: ngx_t_forms_types.DatabaseFormInterface[];
-        } | Observable<{
-            forms: ngx_t_forms_types.DatabaseFormInterface[];
-        }>) => rxjs.Subscription;
-        toggleFormBuilderBusy: () => void;
-        toggleLoadingForm: () => void;
-        toggleLoadingForms: (observableOrValue: {
-            loadingForms: boolean;
-        } | Observable<{
-            loadingForms: boolean;
-        }>) => rxjs.Subscription;
-        loadFormSuccess: (observableOrValue: {
-            form: ngx_t_forms_types.DatabaseFormInterface;
-        } | Observable<{
-            form: ngx_t_forms_types.DatabaseFormInterface;
-        }>) => rxjs.Subscription;
-        toggleFormBusy: (observableOrValue: {
-            formId: string;
-        } | Observable<{
-            formId: string;
-        }>) => rxjs.Subscription;
-        archivedSuccess: (observableOrValue: {
-            formId: string;
-        } | Observable<{
-            formId: string;
-        }>) => rxjs.Subscription;
-        setFormId: (observableOrValue: {
-            formId: string;
-        } | Observable<{
-            formId: string;
-        }>) => rxjs.Subscription;
-        setError: (observableOrValue: {
-            error: string | undefined;
-            type: ngx_t_forms_types.FormStateErrors;
-        } | Observable<{
-            error: string | undefined;
-            type: ngx_t_forms_types.FormStateErrors;
-        }>) => rxjs.Subscription;
-        handleListSectionChange: (observableOrValue: {
-            listSection: FormListSection;
-        } | Observable<{
-            listSection: FormListSection;
-        }>) => rxjs.Subscription;
-        handleRouterStateChange: (observableOrValue: {
-            routerState: _angular_router.ActivatedRouteSnapshot | null;
-        } | Observable<{
-            routerState: _angular_router.ActivatedRouteSnapshot | null;
-        }>) => rxjs.Subscription;
-        handleSetSubmittingForm: (observableOrValue: {
-            submittingForm: boolean;
-        } | Observable<{
-            submittingForm: boolean;
-        }>) => rxjs.Subscription;
-        setFormInitialValues: (observableOrValue: {
-            initialFormValues: Record<string, any>;
-        } | Observable<{
-            initialFormValues: Record<string, any>;
-        }>) => rxjs.Subscription;
-        handleEditorUpdateFormInEdit: (observableOrValue: {
-            form: FormInterface;
-        } | Observable<{
-            form: FormInterface;
-        }>) => rxjs.Subscription;
-        updateFormInputConfigFromTower: (observableOrValue: {
-            inputId: string;
-            config: ngx_t_forms_types.FormColumnInputs;
-        } | Observable<{
-            inputId: string;
-            config: ngx_t_forms_types.FormColumnInputs;
-        }>) => rxjs.Subscription;
-        setInputInEditId: (observableOrValue: {
-            inputInEdit: string | null;
-        } | Observable<{
-            inputInEdit: string | null;
-        }>) => rxjs.Subscription;
-    };
-    readonly actionsFormBuilder: {
-        handelSaveForm: () => void;
-        setFormTitle: (title: string) => void;
-        handleSectionDragDrop: (event: _angular_cdk_drag_drop.CdkDragDrop<any, any, any>) => void;
-        handleInputDragDrop: (event: _angular_cdk_drag_drop.CdkDragDrop<any, any, any>, sectionId: string) => void;
-        handleAddSection: () => void;
-        stepTitleChangeStep: (sectionId: string, title: string) => void;
-        formDeleteInput: (item: ngx_t_forms_types.FormColumnInputs) => void;
-        multipleInputToggleLabel: (item: ngx_t_forms_types.FormColumnInputs) => void;
-        editInput: (item: ngx_t_forms_types.FormColumnInputs) => void;
-        addMultipleInputValueCalculationFunction: (item: ngx_t_forms_types.IMultipleInputCal, multipleInputId: string | undefined) => void;
-        formDeleteSection: (sectionId: string) => void;
-        formDeleteSectionInputs: (sectionId: string) => void;
-        moveInputToSection: (inputId: string, targetSectionId: string) => void;
-        reorderMultipleInputItems: (event: _angular_cdk_drag_drop.CdkDragDrop<ngx_t_forms_types.FormColumnInputs[], any, any>, multipleInputId: string) => void;
-        cloneCopyFormInput: (inputId: string) => void;
-        saveInput: (sectionId: string) => void;
-        applyFormTemplate: (form: FormInterface) => void;
-        selectInputTemplate: (inputId: string, element: ngx_t_forms_types.ElementTypes) => void;
-        formInputChange: (ele: ngx_t_forms_types.ElementEditorInnerSectionElementInterface, value: any) => void;
-        saveSubmitApi: (dataPlaceholder: undefined | {
-            data: ngx_t_forms_types.APIDataFetchingConfigurationInterface;
-        }, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
-        removeSubmissionApi: (api: ngx_t_forms_types.APIDataFetchingConfigurationInterface, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
-        elementConfigurationChanged: (inputId: string, value: any, ele: ngx_t_forms_types.ElementEditorInnerSectionElementInterface) => void;
-        elementBlur: (inputId: string, event: any, element: ngx_t_forms_types.ElementEditorInnerSectionElementInterface) => void;
-        addMultipleFormInput: (sectionId: string, multipleInputInEditId: string) => void;
-        clearInputInEdit: (inputId: string) => void;
-        addInputToScoaSelection: (sectionId: string, scoaInputId: string) => void;
-    };
-    readonly effects: {
-        createForm$: (observableOrValue: FormInterface | Observable<FormInterface>) => rxjs.Subscription;
-        loadForms$: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
-        loadForm$: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
-        updateForm$: (observableOrValue: {
-            form: FormInterface;
-            versionNumber: number;
-        } | Observable<{
-            form: FormInterface;
-            versionNumber: number;
-        }>) => rxjs.Subscription;
-        archiveForm$: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
-        setListSection$: (observableOrValue: FormListSection | Observable<FormListSection>) => rxjs.Subscription;
-        unArchiveForm$: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
-        deleteForm$: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    startTourByOption(steps: IStepOption[]): {
+        stepShow$: rxjs.Subject<ngx_ui_tour_md_menu.StepChangeParams<IStepOption>>;
+        stepHide$: rxjs.Subject<ngx_ui_tour_md_menu.StepChangeParams<IStepOption>>;
+        initialize$: rxjs.Subject<IStepOption[]>;
+        start$: rxjs.Subject<void>;
+        end$: rxjs.Subject<void>;
+        pause$: rxjs.Subject<void>;
+        resume$: rxjs.Subject<void>;
     };
-    refreshExternalFormStates?: (form: FormInterface) => void;
-    registerFormChangeFn(fn: (form: FormInterface) => void): void;
-    createFormPlaceHolderFormGroups(form: FormInterface): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormsStoreService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FormsStoreService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TourManagerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TourManagerService>;
 }
 
-declare class FormsComponent implements OnInit, OnDestroy {
-    private route;
-    private store;
-    private document;
-    subscription$: Subscription;
-    selectFormsList$: Observable<LocalFormStateSelectorInterface[]>;
-    selectGroupedForms$: Observable<Record<string, any[]>>;
-    private searchQuerySubject;
-    searchQuery$: Observable<string>;
-    selectHasActiveSearch$: Observable<boolean>;
-    selectFilteredGroupedForms$: Observable<Record<string, any[]>>;
-    selectLoadingForms$: Observable<boolean>;
-    selectErrors$: Observable<any>;
-    selectFormListSection$: Observable<FormListSection>;
-    NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
-    closeButton: ngx_t_forms_types.ActionButton;
-    constructor(route: ActivatedRoute, store: FormsStoreService, document: Document);
-    ngOnDestroy(): void;
-    get formListSections(): {
-        value: FormListSection;
-        label: string;
-    }[];
-    viewportWidth: number;
-    ngOnInit(): void;
-    labels: {
-        label: string;
-        formControlName: string;
-    }[];
-    activeForm: string | null;
-    getCols(): 1 | 4 | 2 | 3;
-    getFormAvatar(formTitle: string): string;
-    archive(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
-    unarchive(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
-    delete(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
-    loadForms(): void;
-    router: Router;
-    activatedRoute: ActivatedRoute;
-    setSection(value: FormListSection): void;
-    editForm(form: LocalFormStateSelectorInterface): void;
-    addNewForm(): void;
-    clearSearch(): void;
-    get searchQuery(): string;
-    set searchQuery(v: string);
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormsComponent, "app-forms", never, {}, {}, never, never, true, never>;
-}
-
-declare class ValidationExpressioCreatorComponent implements OnDestroy, OnInit {
-    hint: string;
-    label: string;
-    formInputs: FormColumnInputs[];
-    _data: any;
-    set data(value: any);
-    get data(): any;
-    set expression(value: string);
-    _valueAccessRules: Record<string, TreeNode[]>;
-    set valueAccessRules(value: Record<string, TreeNode[]>);
-    get valueAccessRules(): Record<string, TreeNode[]>;
-    subscription$: Subscription;
-    ngOnDestroy(): void;
-    expressionChange: EventEmitter<{
-        expression: string | null;
-        valueAccessRules: Record<string, TreeNode[]>;
-    }>;
-    ngOnInit(): void;
-    textareaElementRef: ElementRef;
-    expressionControl: FormControl<string | null>;
-    cursorPosition: number;
-    showSuggestions: boolean;
-    optionsSearch: string;
-    onTextChange(expression: string): Promise<void>;
-    cleanValueAccessRules(): void;
-    selectSuggestionInput(suggestion: string): void;
-    get getAllInputs(): FormColumnInputs[];
-    onFocus(event: FocusEvent): void;
-    methods: {
-        label: string;
-        hint: string;
-        value: string;
-    }[];
-    getMethods(): {
-        label: string;
-        hint: string;
-        value: string;
-    }[];
-    variableInEdit: string | null;
-    get errorMessage(): string | null;
-    get valueAccessOptions(): string[];
-    activeVariableChanged(value: TreeNode[] | string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationExpressioCreatorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ValidationExpressioCreatorComponent, "lib-validation-expressio-creator", never, { "hint": { "alias": "hint"; "required": false; }; "label": { "alias": "label"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; "data": { "alias": "data"; "required": false; }; "expression": { "alias": "expression"; "required": false; }; "valueAccessRules": { "alias": "valueAccessRules"; "required": false; }; }, { "expressionChange": "expressionChange"; }, never, never, true, never>;
+/**
+ * End-user surface for filling out a form. Extends `FormTowerControllerService`
+ * to drive a `MatStepper` of form sections and renders each section's inputs
+ * via `TFormInputComponent`. Loads the form definition through the consumer's
+ * `formBuilder.getForm` hook on `NgxTFormsConfig`, supports undo (Ctrl+Z),
+ * initial values, and per-instance global system inputs.
+ *
+ * Inputs:
+ *  - `formId: string | undefined` — when set, fetches the form
+ *    definition and initialises the tower controller.
+ *  - `initialValues: Record<string, unknown> | undefined` — seed the form
+ *    with previously captured values; only re-initialises when the value
+ *    actually changes.
+ *  - `globalSystemInputs: FormColumnInputs[]` — system-level inputs
+ *    merged into every step of the form; re-initialises the form when set.
+ *  - `passParamsOnSubmit: Record<string, unknown> | undefined` — extra params
+ *    passed through to the consumer's submit handler.
+ *
+ * Outputs:
+ *  - _None._ Submission and lifecycle events are dispatched through the
+ *    inherited `FormTowerControllerService` and the consumer's
+ *    `formActions` / `formBuilder` callbacks.
+ */
+declare class UserFormStepperComponent {
+    #private;
+    /**
+     * Runtime form engine, held by composition (SIGNAL_FORMS Phase 0, D-025).
+     * Provided per-component instance; the component reaches the former
+     * inherited tower surface through this façade.
+     */
+    protected readonly engine: TFormEngine;
+    /** Form definition id; when set, the component fetches and initialises the form. */
+    readonly formId: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Seed values applied to the form once it is initialised.
+     *
+     * A keyed record of previously captured values (raw API payloads, partial
+     * form values, nested objects). The downstream `initializeFormValues`
+     * consumes the entries defensively; callers narrow specific value shapes.
+     */
+    readonly initialValues: _angular_core.InputSignal<Record<string, unknown> | undefined>;
+    /** System-level inputs merged into every step of the form. */
+    readonly globalSystemInputs: _angular_core.InputSignal<FormColumnInputs[]>;
+    /**
+     * Extra params forwarded to the consumer's submit handler.
+     *
+     * A keyed record merged into the submission payload; only meaningful to the
+     * consumer's own submit handler, which narrows the individual values.
+     */
+    readonly passParamsOnSubmit: _angular_core.InputSignal<Record<string, unknown> | undefined>;
+    /** Underlying Material stepper instance (may be undefined before first CD pass). */
+    readonly stepper: _angular_core.Signal<MatStepper | undefined>;
+    /** Whether the form is editable / can be navigated freely. */
+    isEditable: boolean;
+    /** True while the form definition is being fetched. */
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    protected readonly tourManagerService: TourManagerService;
+    protected readonly formIdBridge: _angular_core.EffectRef;
+    protected readonly initialValuesBridge: _angular_core.EffectRef;
+    protected readonly globalSystemInputsBridge: _angular_core.EffectRef;
+    /**
+     * Handles the key down event and reverts the form's last history entry on Ctrl+Z.
+     * @param event The keyboard event object.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    loadForm(formId: string | undefined): void;
+    /**
+     * Builder-function shim passed to inputs that need callbacks (e.g.
+     * MultipleInput, MSCOA). The user form surface only implements the subset
+     * relevant to runtime input editing; builder-only members (`editInput`,
+     * `deleteInput`, `addFunction`, `reorderItems`, `multipleInputToggleLabel`)
+     * are stubbed because they have no meaning outside the form builder.
+     */
+    get formBuilderFunctions(): FormBuilderFunctions;
+    getStepState(step: ITowerFormSteps, index: number): StepState;
+    getPreviousStepLabel(): string | undefined;
+    getNextStepLabel(): string | undefined;
+    canProceedToNextStep(step: ITowerFormSteps): boolean;
+    get getSubmissionStatus(): string;
+    handleSubmit(): void;
+    /** Still-failing overridable validations the user may motivate to submit. */
+    get overridableErrors(): OverridableError[];
+    /** True while a blocking (non-overridable) error keeps submission impossible. */
+    get hasBlockingErrors(): boolean;
+    /** True once every blocking error is resolved and every override is motivated. */
+    get canSubmit(): boolean;
+    /** Current motivation text for one overridable validation (for two-way display). */
+    overrideComment(validatorId: string): string;
+    /** File name of the attachment captured for one overridable validation, if any. */
+    overrideAttachmentName(validatorId: string): string | undefined;
+    /** Records the motivation comment as the user types. */
+    onOverrideComment(validatorId: string, event: Event): void;
+    /**
+     * Reads the chosen supporting file into a base64 {@link FileData} and attaches
+     * it to the override; clearing the picker removes the attachment. Browser-only
+     * (FileReader) — a no-op under SSR.
+     */
+    onOverrideAttachment(validatorId: string, event: Event): Promise<void>;
+    get hasTour(): boolean;
+    /**
+     * Initiates and configures a dynamic, multi-step tutorial tour for the form.
+     * The tour guides the user through the form's title, sections, and individual fields.
+     */
+    startTour(): void;
+    refreshASection(sectionId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserFormStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserFormStepperComponent, "lib-user-form-stepper", never, { "formId": { "alias": "formId"; "required": false; "isSignal": true; }; "initialValues": { "alias": "initialValues"; "required": false; "isSignal": true; }; "globalSystemInputs": { "alias": "globalSystemInputs"; "required": false; "isSignal": true; }; "passParamsOnSubmit": { "alias": "passParamsOnSubmit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare function testAgainstItem(test: ConfigurationValidTestInterface, item: any): boolean;
-
 interface IConfigElementError {
     key: string;
     message: string;
 }
-declare class TDynamicDataEditComponent implements OnDestroy {
-    private ngZone;
-    private editorInitiated;
-    constructor(ngZone: NgZone);
-    ngOnDestroy(): void;
-    private valueChanges;
-    private subscription;
-    elementEditorTypes: typeof ElementEditorTypes;
-    private _editorConfig;
-    private _data;
-    set editorConfig(config: ElementEditorInnerSectionElementInterface | undefined);
-    _formInputs$: BehaviorSubject<FormColumnInputs[]>;
-    _formInputs: FormColumnInputs[];
-    set formInputs(inputs: Array<FormColumnInputs>);
-    get formInputs(): Array<FormColumnInputs>;
-    set data(data: any);
-    get data(): any;
-    validationErrors: IConfigElementError[] | null;
-    valueChange: EventEmitter<unknown>;
-    blur: EventEmitter<any>;
-    editorConfigValue$: Observable<ElementEditorInnerSectionElementInterface | undefined>;
-    dataValue$: Observable<any>;
-    get getMscoaTree$(): Observable<IGetTreeResponse | undefined>;
-    get getWorkflowOptions$(): Observable<IWorkflowOption[] | undefined>;
-    get value$(): Observable<any>;
-    get dataOptions$(): Observable<any>;
-    get disabled$(): Observable<boolean | undefined>;
-    private initializeValueChanges;
-    private computeValueChange;
-    inputChange(event: any): void;
+/**
+ * Builder-side editor for a single configurable property on a form input —
+ * dispatches to the correct editor (selection options, REST API setup,
+ * value-access rules, pipeline, validators, MSCOA segment config, slider,
+ * chip list, data source picker, document list label config, workflow
+ * picker, EditorJS, record list manager, etc.) based on the supplied
+ * `ElementEditorInnerSectionElementInterface`.
+ *
+ * @remarks
+ * Emits debounced value changes (and a separate `blur` event when the
+ * editor is a free-text expression) so the form builder can persist edits
+ * without re-reading the underlying form on every keystroke.
+ *
+ * Inputs:
+ *  - `editorConfig: ElementEditorInnerSectionElementInterface | undefined`
+ *    — descriptor of the editor to render.
+ *  - `formInputs: FormColumnInputs[]` — the set of inputs the
+ *    editor can reference (used by expression / value-access editors).
+ *  - `data: unknown` — current value being edited; resets the value
+ *    pipeline when changed by reference.
+ *  - `validationErrors: IConfigElementError[] | null` — validation errors
+ *    surfaced by the parent for display.
+ *
+ * Outputs:
+ *  - `valueChange` — fires when the edited value changes (debounced).
+ *  - `blur` — fires when an inner editor loses focus
+ *    (used for expression-style editors).
+ */
+declare class TDynamicDataEditComponent {
+    #private;
+    protected readonly elementEditorTypes: typeof ElementEditorTypes;
+    /** Descriptor of the editor to render. */
+    readonly editorConfig: _angular_core.InputSignal<ElementEditorInnerSectionElementInterface | undefined>;
+    /** The set of inputs the editor can reference (used by expression / value-access editors). */
+    readonly formInputs: _angular_core.InputSignal<FormColumnInputs[]>;
+    /**
+     * Current value being edited; resets the value pipeline when changed by reference.
+     * @remarks Heterogeneous across consumers (ITowerStepColumn, plain records, etc.),
+     * so it is typed as a keyed record; the editor pipeline reads individual fields
+     * via `deepBind` paths and callers narrow specific value shapes.
+     */
+    readonly data: _angular_core.InputSignal<unknown>;
+    /** Validation errors surfaced by the parent for display. */
+    readonly validationErrors: _angular_core.InputSignal<IConfigElementError[] | null>;
+    /** Fires when the edited value changes (debounced). */
+    readonly valueChange: _angular_core.OutputEmitterRef<unknown>;
+    /** Fires when an inner editor loses focus (used for expression-style editors). */
+    readonly blur: _angular_core.OutputEmitterRef<unknown>;
+    protected readonly editorConfigBridge: _angular_core.EffectRef;
+    protected readonly dataBridge: _angular_core.EffectRef;
+    protected readonly editorConfigValue$: Observable<ElementEditorInnerSectionElementInterface | undefined>;
+    protected readonly dataValue$: Observable<Record<string, unknown> | undefined>;
+    protected get getMscoaTree$(): Observable<IGetTreeResponse | undefined>;
+    protected get getWorkflowOptions$(): Observable<IWorkflowOption[] | undefined>;
+    protected get value$(): Observable<{} | null>;
+    protected get dataOptions$(): Observable<unknown>;
+    protected get disabled$(): Observable<boolean | undefined>;
+    inputChange(event: unknown): void;
     valueChanged(value: unknown): void;
     manualValueChange(event: {
         value: unknown;
         deepBind: Array<string>;
     }): void;
     blurOff: boolean;
-    elementBlur(event: any): void;
-    get inputHasBlurFunction$(): Observable<BlurHandleTypes | undefined>;
-    blurFunctionTooltip(blurHandle: BlurHandleTypes | undefined): "Enable/disable pre-populating of the form control name from the label" | "Enable/disable auto conversion of control name to camel case" | "Toggle blur function";
-    formatLabel: (value: number) => any;
-    vm$: Observable<{
+    elementBlur(event: unknown): void;
+    protected get inputHasBlurFunction$(): Observable<BlurHandleTypes | undefined>;
+    blurFunctionTooltip(blurHandle: BlurHandleTypes | undefined): string;
+    /** Slider label formatter — Mat slider's `displayWith` accepts `string | number`. */
+    formatLabel: (value: number) => string | number;
+    protected vm$: Observable<{
         editorConfigValue: ElementEditorInnerSectionElementInterface | undefined;
-        value: any;
+        isFormFieldControl: boolean;
+        value: {} | null;
         dataOptions: any;
         disabled: boolean | undefined;
         inputHasBlurFunction: BlurHandleTypes | undefined;
-        dataValue: any;
-        inputConfig: any;
+        dataValue: Record<string, unknown> | undefined;
+        inputConfig: Partial<ITowerStepColumn>;
     }>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TDynamicDataEditComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TDynamicDataEditComponent, "lib-t-dynamic-data-edit", never, { "editorConfig": { "alias": "editorConfig"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; "data": { "alias": "data"; "required": false; }; "validationErrors": { "alias": "validationErrors"; "required": false; }; }, { "valueChange": "valueChange"; "blur": "blur"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TDynamicDataEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TDynamicDataEditComponent, "lib-t-dynamic-data-edit", never, { "editorConfig": { "alias": "editorConfig"; "required": false; "isSignal": true; }; "formInputs": { "alias": "formInputs"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; }, never, never, true, never>;
 }
 
 declare class TreeComponent {
@@ -641,7 +1160,7 @@ declare class TreeComponent {
         inEdit?: boolean;
         path: string[];
         keyIsArrayIndex?: boolean;
-        functions: ngx_t_forms_types.IArrayFunction[];
+        functions: IArrayFunction[];
     }[] | undefined;
     resetNode(): void;
     removeFunction(id: string): void;
@@ -655,145 +1174,662 @@ declare class TreeComponent {
     dataSource: MatTreeFlatDataSource<TreeNode, FlatNode, FlatNode>;
     private dynamicObject;
     constructor();
-    computeTreeData(dynamicObject: any): void;
+    computeTreeData(dynamicObject: unknown): void;
     assignDataSourceData(tree: TreeNode[]): void;
     hasChild: (_: number, node: FlatNode) => boolean;
-    getValue(): any;
+    getValue(): unknown;
     addNewFunction(): void;
     functionChanged(value: string): void;
 }
 
+/**
+ * Read-only tree view for an arbitrary JSON-shaped value. Converts the input
+ * into a flat tree (via `TreeComponent`) and renders each leaf with a typed
+ * style class (`value-string`, `value-number`, `value-boolean`, `value-null`).
+ */
 declare class TDynamicDataViewComponent {
-    treeClass: TreeComponent;
-    data: any;
+    /** Arbitrary JSON-shaped value to render. Recomputes the tree on structural change. */
+    readonly data: _angular_core.InputSignal<unknown>;
+    protected readonly treeClass: TreeComponent;
     constructor();
-    _data: any;
-    ngOnInit(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    getNodeValueColor(value: any): "green" | "blue" | "purple" | "black";
-    static ɵfac: i0.ɵɵFactoryDeclaration<TDynamicDataViewComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TDynamicDataViewComponent, "lib-t-dynamic-data-view", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+    protected formatKey(key: string): string;
+    protected getDisplayValue(value: unknown): string;
+    protected getValueClass(value: unknown): string;
+    protected getLevelArray(node: unknown): readonly number[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TDynamicDataViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TDynamicDataViewComponent, "lib-t-dynamic-data-view", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class MscoaFormInputComponent {
-    inputConfig: ITowerStepColumn;
-    editorMode: boolean;
-    formGroup: FormGroup;
-    formBuilderFunctions: FormBuilderFunctions | undefined;
-    reload: EventEmitter<void>;
-    get errorMessage(): string | string[] | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MscoaFormInputComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MscoaFormInputComponent, "lib-mscoa-form-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "editorMode": { "alias": "editorMode"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; }, { "reload": "reload"; }, never, never, true, never>;
+declare class FormatDataPipe implements PipeTransform {
+    /**
+     * Formats an arbitrary input value for display according to `dataType`.
+     *
+     * `value` is typed `unknown` (a pipe can be handed any binding) and each
+     * branch narrows it to the shape it needs. The return is the set of
+     * display-primitive types (`string | number | null | undefined`) so it
+     * binds cleanly to interpolation and `matTooltip`; "passthrough" branches
+     * return the original value (asserted to the display-primitive union — its
+     * runtime value is unchanged and Angular string-coerces it for display).
+     *
+     * @param value      - The raw value to format.
+     * @param dataType   - Which formatting branch to apply.
+     * @param pipeConfig - Optional pipe configuration (currency code, nested pipe type).
+     * @returns The formatted representation, or the original value when no formatting applies.
+     */
+    transform(value: unknown, dataType: DocumentLitsLabelConfigInterfaceValueType | InputDataTypes | undefined | InputPipeTypes, pipeConfig?: FormColumnInputs['pipe'] | undefined): string | number | null | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormatDataPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FormatDataPipe, "formatData", true>;
 }
 
-interface EncryptedData {
-    ciphertext: string;
-    salt: string;
-    iv: string;
-    hmac: string;
+/**
+ * @public
+ * @deprecated Reachable for one minor cycle only as part of the Phase 1 public-surface
+ *   lockdown. Target removal: v3.0.0. No replacement — this is the empty
+ *   `ng generate library` stub and will be deleted in Phase 2.
+ */
+declare class NgxTFormsService {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxTFormsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgxTFormsService>;
 }
 
-declare const getSignatureImage: (inputConfig: FormColumnInputs, value: EncryptedData | undefined) => Promise<string | undefined>;
-
-declare class SignatureInputElementComponent {
-    inputConfig: ITowerStepColumn;
-    formGroup: FormGroup;
-    reload: EventEmitter<void>;
-    get errorMessage(): string | string[] | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SignatureInputElementComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SignatureInputElementComponent, "lib-signature-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "reload": "reload"; }, never, never, true, never>;
+/**
+ * @public
+ * @deprecated Reachable for one minor cycle only as part of the Phase 1 public-surface
+ *   lockdown. Target removal: v3.0.0. No replacement — this is the empty
+ *   `ng generate library` stub and will be deleted in Phase 2.
+ */
+declare class NgxTFormsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxTFormsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxTFormsComponent, "lib-ngx-t-forms", never, {}, {}, never, never, true, never>;
 }
 
-declare class TFormInputComponent {
-    private props;
-    inputConfig: ITowerStepColumn | undefined;
-    formGroup: FormGroup<{
-        [sectionId: string]: FormGroup<{
-            [inputId: string]: FormControl<string | null>;
-        }>;
-    }> | undefined | null;
-    editorMode: boolean;
-    formBuilderFunctions: FormBuilderFunctions | undefined;
-    optionsSearchWordKeyWord: string;
-    elementTypes: typeof ElementTypes;
-    constructor(props: any);
-    get hasFormControlInstance(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TFormInputComponent, [{ optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TFormInputComponent, "lib-t-form-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "editorMode": { "alias": "editorMode"; "required": false; }; "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; }, {}, never, never, true, never>;
+/**
+ * Public entry-point for bulk imports.
+ *
+ * Typical usage:
+ * ```ts
+ * const importController = inject(TFormImportController);
+ * importController.progress$.subscribe(p => render(p));    // optional reactive UI
+ * const results = await importController.runImport(form, rows);
+ * const validRows = results.filter(r => r.isValid);
+ * ```
+ *
+ * Singleton (`providedIn: 'root'`) because all import sessions share the same
+ * caches/injector wiring. Call {@link TFormImportController.reset} between
+ * runs only if you want to force consumers of `progress$` to see an empty
+ * baseline; `runImport` already clears caches on entry and exit.
+ *
+ * @public
+ * @deprecated Reachable for one minor cycle only as part of the Phase 1 public-surface
+ *   lockdown. Target removal: v3.0.0. Consumers should switch to wiring an import flow
+ *   through the `withImportTower()` feature; the controller will move under that
+ *   feature tree in Phase 2.
+ */
+declare class TFormImportController {
+    private readonly _injector;
+    private readonly _rows$;
+    /**
+     * Per-session HTTP caches.
+     * Key: serialized request identity → shared Observable (shareReplay).
+     * Populated at the start of runImport and cleared when it finishes,
+     * so every import session starts cold but identical in-flight requests
+     * across concurrent rows reuse a single HTTP call.
+     */
+    private _getCache;
+    private _postCache;
+    /**
+     * Registry of pre-processors keyed by ElementType.
+     * Add an entry here to handle a new input type in _preProcessRow — no other
+     * changes needed. Each processor receives the column definition and the raw
+     * row and must return `{ value?, errors[] }`.
+     * `value` is written to processedRow[formControlName] when defined;
+     * `errors` accumulates in colErrors[formControlName].
+     */
+    private readonly _inputPreProcessors;
+    /**
+     * Shared financial-cycles observable for the current import session.
+     * loadSystemInputs calls getFinacialCycles() directly via NGX_T_FORMS_CONFIG
+     * (not through utils), so HTTP-function patching alone cannot deduplicate it.
+     * We intercept it at the config level by providing a wrapped token in each
+     * tower's child injector that returns this shared observable instead.
+     */
+    private _financialCycles$;
+    /**
+     * Reactive progress stream — subscribe to track each row in real time.
+     */
+    readonly progress$: Observable<ImportProgress>;
+    /**
+     * Snapshot of the current progress (non-reactive).
+     */
+    get currentProgress(): ImportProgress;
+    /**
+     * Runs an import session.
+     *
+     * For each row a fresh tower instance is spun up via a child injector,
+     * prepopulated, and left to settle (calculations + API fetches) before
+     * recording the final value and validation status.
+     * All rows are processed concurrently.
+     *
+     * Usage:
+     * ```ts
+     * const results = await importController.runImport(form, rows);
+     * const valid   = results.filter(r => r.isValid);
+     * ```
+     *
+     * @param form  The form definition every row is validated against.
+     * @param rows  Raw data objects — one per import row.
+     */
+    runImport(form: FormInterface, rows: Record<string, unknown>[]): Promise<ImportRowState[]>;
+    /** Clears all row state. */
+    reset(): void;
+    /**
+     * Creates an isolated tower instance through a short-lived child injector.
+     *
+     * The child injector delegates all token resolution to the parent, so
+     * HttpClient, NGX_T_FORMS_CONFIG_TOKEN, and any other deps the tower needs
+     * are found automatically — no manual wiring required here.
+     *
+     * After creation the tower's HTTP functions are replaced with cache-aware
+     * wrappers so that identical requests fired by different rows share one
+     * in-flight Observable instead of each issuing their own HTTP call.
+     */
+    private _createTower;
+    /**
+     * Returns a shared Observable for a GET request.
+     * On cache miss the original function is called once and its result is
+     * multicasted via shareReplay(1) so every concurrent subscriber (row) that
+     * asks for the same URL+options receives the same response without an
+     * additional HTTP call.
+     */
+    private _cachedGet;
+    /**
+     * Returns a shared Observable for a POST request.
+     * Keyed by URL + serialised body + serialised options so only truly
+     * identical requests are deduplicated.
+     */
+    private _cachedPost;
+    /**
+     * End-to-end pipeline for a single import row. Runs concurrently with every
+     * other row in the session.
+     *
+     * Steps (any thrown error short-circuits to `status: 'error'`):
+     * 1. Mark the row `processing`.
+     * 2. Spin up an isolated tower via {@link TFormImportController._createTower}.
+     * 3. `initialize(form, { skipInitialFunctions: true })` — see the flag's
+     *    docs; this avoids the timing race between the tower's initial async
+     *    work and our synchronous `initializeFormValues`.
+     * 4. `_preProcessRow` resolves nested formats (SCOA codes, multi-select
+     *    strings, MultipleInput sub-rows) into the shape `initializeFormValues`
+     *    expects.
+     * 5. Apply the resolved row → tower's changeMonitor cycle fires dependent
+     *    functions → busy=true.
+     * 6. `waitUntilSettled()` blocks until every async op drains.
+     * 7. `markAllAsTouched()` so required-field validators surface even on
+     *    untouched controls.
+     * 8. {@link TFormImportController._recomputeAllValidationErrors} re-runs
+     *    sync validators across the whole tree (matches what
+     *    `getInputErrorMessage` reports in the interactive UI).
+     * 9. Collect settled values + per-input + per-column errors and update the
+     *    row's state.
+     *
+     * `finally` always destroys the tower so child injectors / valueChanges
+     * subscriptions don't leak across rows.
+     */
+    private _processRow;
+    /**
+     * Dispatches each column that has a registered pre-processor, collects
+     * resolved values and errors, then returns the enriched row.
+     *
+     * To support a new input type add an entry to `_inputPreProcessors` —
+     * nothing else needs to change here.
+     */
+    private _preProcessRow;
+    /**
+     * Pre-processor for MscoaSelection inputs.
+     *
+     * Resolves flat account codes into full IScoaAccount objects.
+     * Column naming convention expected in the raw row:
+     *   {formControlName}.{basisKey}.{SEGMENT}.debit   e.g. "glAccount.accrual.FUND.debit"
+     *   {formControlName}.{basisKey}.{SEGMENT}.credit  e.g. "glAccount.cash.COSTING.credit"
+     *
+     * Returns the nested structure that `initializeFormValues` / the mscoa
+     * component store expect:
+     *   { accrual: { FUND: { debit: IScoaAccount, credit: IScoaAccount } }, cash: { ... } }
+     */
+    private _processMscoaInput;
+    /**
+     * Pre-processor for MultipleInput inputs.
+     *
+     * Expects `row[input.formControlName]` to be an array of objects where each
+     * object's keys are the formControlNames declared in `input.formInputs`.
+     *
+     * For each item the full tower lifecycle is run against a one-slide mock form
+     * (the same sequence as _processRow on the main form), so Angular validators,
+     * async validators, API calls, and calculated fields all fire and settle before
+     * errors are collected. Pre-processors (e.g. MscoaSelection) are applied first
+     * so resolved objects are in place when the tower initializes.
+     *
+     * Errors are prefixed with the item index: "[0].subField.errorCode".
+     */
+    private _processMultipleFormInput;
+    /**
+     * Resolves a single account code to an IScoaAccount.
+     * Routed through `_cachedGet` so identical codes across concurrent rows share
+     * one in-flight Observable (shareReplay) — the same mechanism used for all
+     * other HTTP calls in this class.
+     */
+    private _lookupScoaAccount;
+    /**
+     * Pre-processor for `Select` and `PaginatedSelectionTable` inputs.
+     *
+     * Single-select inputs pass through unchanged.
+     *
+     * Multi-select inputs accept the value in any of:
+     * - `string[]` — taken as-is, each entry trimmed.
+     * - `'["a","b"]'` — JSON-stringified array.
+     * - `'a, b, c'` — comma-separated string.
+     * - `'[a, b]'` (malformed JSON) — fallback: strip brackets, split, strip quotes.
+     *
+     * If the input declares custom (in-config) options, every parsed value is
+     * checked against the option set. Any mismatches are returned as errors of
+     * the form `'invalidOption:<value>'` and `value` is omitted (so the parent
+     * form control keeps its original/empty state and the row is flagged
+     * invalid). API-fetched options are NOT validated here — see the comments
+     * in {@link FormTowerControllerService.initialize} on why deferring those
+     * lookups is safe in import mode.
+     */
+    private _processSelectInput;
+    /**
+     * Re-runs sync validation across the WHOLE form tree against the settled values.
+     *
+     * **Why this is still required after the signal-forms migration (Phase 1.5 finding;
+     * kept until Phase 3):** it is NOT a settle-timing workaround — Phase 1 already made
+     * `waitUntilSettled` deterministic. It compensates for two reactive-forms semantics
+     * the signal-graph engine does not change:
+     *
+     * 1. **Cross-field validators.** Custom validators (commonFormOperations
+     *    `createCustomValidator`) read OTHER fields via `getFormValue()`. Angular only
+     *    re-runs a control's validators when ITS OWN value changes, and the engine's
+     *    projection effect likewise only `setValue`s controls whose value actually
+     *    changed — so a control whose value is unchanged keeps STALE cross-field errors
+     *    until a whole-tree `updateValueAndValidity` forces re-evaluation.
+     * 2. **Disabled controls.** Angular never validates disabled controls (formGenerator
+     *    disables them from `input.disabled`); import temporarily enables the tree,
+     *    validates, then restores the disabled flags.
+     *
+     * Phase 3 (`@angular/forms/signals` `validate()`/`validateAsync()`) makes validation
+     * reactive over observed fields and disabled-aware — at which point this method, its
+     * enable/disable dance, and this call site can be deleted.
+     */
+    private _recomputeAllValidationErrors;
+    /**
+     * Walks `{ [sectionId]: FormGroup { [inputId]: FormControl } }` and
+     * collects every control that has validation errors (from `control.errors`).
+     */
+    private _collectValidationErrors;
+    /**
+     * Groups the flat overridable-error list from {@link partitionFormErrors} into
+     * an `inputId → messages[]` map for {@link ImportRowState.overridableErrors}.
+     */
+    private _groupOverridableByInput;
+    /**
+     * Builds a formControlName-keyed error map from the settled form.
+     * Multiple error keys on one control are joined with '.'.
+     */
+    private _collectColErrors;
+    /**
+     * Immutable row update — clones the rows array and the targeted row before
+     * pushing through `_rows$` so subscribers downstream of `progress$` always
+     * receive a fresh reference (cheap change detection in components).
+     */
+    private _patchRow;
+    /**
+     * Compute the {@link ImportProgress} aggregate from the row array. Pure —
+     * driven by `progress$` and `currentProgress`.
+     */
+    private _toProgress;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TFormImportController, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TFormImportController>;
 }
 
-declare class TourManagerService {
-    private readonly tourService;
-    userProfile: this;
-    constructor();
-    startTourByOption(steps: IStepOption[]): {
-        stepShow$: rxjs.Subject<ngx_ui_tour_core.StepChangeParams<IStepOption>>;
-        stepHide$: rxjs.Subject<ngx_ui_tour_core.StepChangeParams<IStepOption>>;
-        initialize$: rxjs.Subject<IStepOption[]>;
-        start$: rxjs.Subject<void>;
-        end$: rxjs.Subject<void>;
-        pause$: rxjs.Subject<void>;
-        resume$: rxjs.Subject<void>;
-    };
-    static ɵfac: i0.ɵɵFactoryDeclaration<TourManagerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TourManagerService>;
+/**
+ * Provides a unique identifier for each tower instance created during an
+ * import run — one id per imported row. The form import controller uses this
+ * to disambiguate concurrent tower contexts when materialising rows into
+ * form submissions.
+ *
+ * @see provideNgxTForms
+ *
+ * @public
+ * @deprecated Internal token used by `TFormImportController`. Will be relocated
+ *   under the `withImportTower()` feature tree in Phase 2; the token (or its
+ *   renamed/improved successor) will remain callable. See DECISIONS.md D-014.
+ */
+declare const IMPORT_TOWER_INSTANCE_ID: InjectionToken<string>;
+
+/**
+ * Generates a hierarchical form with nested FormGroups based on section IDs.
+ * Parent form listens to all descendant changes, with validation cascading upward.
+ *
+ * @param inputs Array of form inputs with their configurations
+ * @param getFormValue Record of form values used for custom validation
+ * @returns A FormGroup with nested FormGroups for each section
+ *
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare function formGenerator(inputs: Array<FormColumnInputs>, getFormValue: () => Record<string, any>): FormGroup;
+
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare function getSectionElements(elements: ElementEditorInnerSectionElementInterface[], inputInEdit: (FormColumnInputs) | undefined, NGX_T_FORMS_CONFIG: NgxTFormsConfig, utils: InClassFormUtilsInterface, errors?: ValidationError[]): ElementEditorInnerSectionElementInterface[];
+
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare const returnMappedPathValue: (pathMap: TreeNode[], obj: unknown) => unknown;
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare const getValueFromValueAccessor: (valueAccessRules: FormInputBasicOptionInterface | TreeNode[] | Record<string, TreeNode[]>, data: unknown) => unknown;
+
+/**
+ * One entry in the polymorphic-input registry. Maps an `ElementTypes` value to
+ * a lazily-loaded renderer plus the metadata the host needs to wire it.
+ *
+ * Each `load()` is a dynamic `import()`, so every renderer is code-split out of
+ * the host bundle — a form with only text fields never downloads the editor,
+ * camera, signature pad, MSCOA charts, etc. The dynamic boundary also breaks
+ * the otherwise-circular import between the host and `ImageCapture`.
+ */
+interface ElementEntry {
+    /** Lazy loader for the concrete renderer component. */
+    readonly load: () => Promise<Type<unknown>>;
+    /**
+     * `true` when the renderer also accepts `editorMode` and
+     * `formBuilderFunctions` inputs. The host only forwards those two inputs to
+     * builder-aware entries, so `NgComponentOutlet` never tries to set an input
+     * the target component does not declare.
+     */
+    readonly builderAware?: boolean;
 }
 
-declare class UserFormStepperComponent extends FormTowerControllerService {
+type TFormInputFormGroup = FormGroup<{
+    [sectionId: string]: FormGroup<{
+        [inputId: string]: FormControl<string | null>;
+    }>;
+}> | undefined | null;
+/**
+ * Polymorphic input host — given an `ITowerStepColumn` descriptor, selects
+ * and renders the correct concrete input component (text, select, date,
+ * file upload, signature, geo-location, MSCOA, document picker, workflow
+ * adjudication, etc.) and wires it to the parent reactive `FormGroup`.
+ *
+ * @remarks
+ * Accepts portal-style prop injection via the optional `'COMPONENT_PROPS'`
+ * token so it can be rendered through `ComponentPortal` with inputs supplied
+ * dynamically.
+ *
+ * Inputs:
+ *  - `inputConfig: ITowerStepColumn | undefined` — descriptor of the input
+ *    to render; the `element` field selects the concrete renderer.
+ *  - `formGroup: FormGroup<{...}> | undefined | null` — the parent reactive
+ *    form group keyed by section id then input id.
+ *  - `editorMode: boolean` — default `false`; when `true`, renders the
+ *    builder-side variant.
+ *  - `formBuilderFunctions: FormBuilderFunctions | undefined` — builder
+ *    hooks passed through to inputs that need them (e.g., MSCOA).
+ *
+ * Outputs:
+ *  - `valueChange: unknown` — emits the input's new value whenever the user
+ *    edits the bound `FormControl`. Concrete child inputs are rendered through
+ *    `NgComponentOutlet` (which forwards inputs only, never outputs) and write
+ *    their value through the shared `FormGroup` via `ControlValueAccessor`, so
+ *    this host bridges those control edits into a single output the tower wires
+ *    to `engine.updateValue(col.id, $event)`. Without this bridge user edits
+ *    reach the projected `FormGroup` (so submission works) but never reach the
+ *    engine's `#model`, leaving the signal graph blind to user input — no
+ *    dependent calculation, value-fetch, or options-fetch ever re-fires.
+ *
+ * @public
+ */
+declare class TFormInputComponent {
+    #private;
     /**
-     * Handles the key down event and opens the application log if the key combination is pressed.
-     * @param event The keyboard event object.
+     * Descriptor of the input to render. `element` selects the concrete renderer.
+     *
+     * Modeled as a `model()` (not `input()`) so that portal-style injection via
+     * `'COMPONENT_PROPS'` can write into the signal at construction time — signal
+     * inputs are read-only at runtime, but model signals are writable via `.set()`.
      */
-    onKeyDown(event: KeyboardEvent): void;
-    _formId: string | undefined;
-    set formId(value: string | undefined);
-    loading: boolean;
-    loadForm(formId: string | undefined): void;
-    _initialFormValuesLocal: any;
-    set initialValues(initialFormValues: any);
-    set globalSystemInputs(inputs: FormColumnInputs[]);
-    passParamsOnSubmit: any;
-    get formBuilderFunctions(): FormBuilderFunctions;
-    stepper: MatStepper | undefined;
-    isEditable: boolean;
-    getStepState(step: any, index: number): StepState;
-    getPreviousStepLabel(): string | undefined;
-    getNextStepLabel(): string | undefined;
-    canProceedToNextStep(step: any): boolean;
-    get getSubmissionStatus(): string;
-    handleSubmit(): void;
-    tourManagerService: TourManagerService;
-    get hasTour(): boolean;
+    readonly inputConfig: _angular_core.ModelSignal<ITowerStepColumn | undefined>;
+    /** Parent reactive `FormGroup` keyed by section id then input id. */
+    readonly formGroup: _angular_core.ModelSignal<TFormInputFormGroup>;
+    /** When `true`, renders the builder-side variant. */
+    readonly editorMode: _angular_core.ModelSignal<boolean>;
+    /** Builder hooks passed through to inputs that need them (e.g., MSCOA). */
+    readonly formBuilderFunctions: _angular_core.ModelSignal<FormBuilderFunctions | undefined>;
     /**
-     * Initiates and configures a dynamic, multi-step tutorial tour for the form.
-     * The tour guides the user through the form's title, sections, and individual fields.
+     * Emits the input's new value on every user-originated edit of the bound
+     * control. The tower binds this to `engine.updateValue(col.id, $event)`,
+     * which is the ONLY path user input takes into the engine's `#model` (and
+     * therefore the signal-graph dependency reactivity). The projection effect
+     * patches controls with `{ emitEvent: false }`, so signal→control writes do
+     * NOT echo back here — only genuine user edits emit.
      */
-    startTour(): void;
-    refreshASection(sectionId: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<UserFormStepperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<UserFormStepperComponent, "lib-user-form-stepper", never, { "formId": { "alias": "formId"; "required": false; }; "initialValues": { "alias": "initialValues"; "required": false; }; "globalSystemInputs": { "alias": "globalSystemInputs"; "required": false; }; "passParamsOnSubmit": { "alias": "passParamsOnSubmit"; "required": false; }; }, {}, never, never, true, never>;
+    readonly valueChange: _angular_core.OutputEmitterRef<unknown>;
+    protected readonly elementTypes: typeof ElementTypes;
+    /**
+     * Polymorphic-host control flag — true when the bound `FormGroup` already
+     * has a `FormControl` (or, for `DateRangePicker`, both start/end controls)
+     * matching the descriptor's `id`.
+     */
+    protected readonly hasFormControlInstance: _angular_core.Signal<boolean>;
+    /**
+     * Registry entry for the current descriptor's element type. Resolves to the
+     * basic-input fallback for unknown types, mirroring the former `@default`
+     * switch branch. `undefined` only while no descriptor is bound.
+     */
+    protected readonly elementEntry: _angular_core.Signal<ElementEntry | undefined>;
+    /**
+     * Lazily-loaded renderer component for the current element type, unwrapped in
+     * the template via the `async` pipe. The promise is re-created only when the
+     * resolved entry changes, so editing other descriptor fields does not reload
+     * the component.
+     */
+    protected readonly elementComponent: _angular_core.Signal<Promise<Type<unknown>> | null>;
+    /**
+     * Inputs forwarded to the resolved renderer. Builder-aware renderers also
+     * receive `editorMode` and `formBuilderFunctions`; every other renderer gets
+     * only `inputConfig` and `formGroup`, so `NgComponentOutlet` never sets an
+     * input the target component does not declare.
+     */
+    protected readonly elementInputs: _angular_core.Signal<Record<string, unknown>>;
+    constructor(props: Record<string, unknown> | null);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TFormInputComponent, [{ optional: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TFormInputComponent, "lib-t-form-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; "editorMode": { "alias": "editorMode"; "required": false; "isSignal": true; }; "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; "isSignal": true; }; }, { "inputConfig": "inputConfigChange"; "formGroup": "formGroupChange"; "editorMode": "editorModeChange"; "formBuilderFunctions": "formBuilderFunctionsChange"; "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
-declare class FormatDataPipe implements PipeTransform {
-    transform(value: any, dataType: DocumentLitsLabelConfigInterfaceValueType | InputDataTypes | undefined | InputPipeTypes, pipeConfig?: FormColumnInputs['pipe'] | undefined): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormatDataPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<FormatDataPipe, "formatData", true>;
+/**
+ * Renders an MSCOA (Municipal Standard Chart of Accounts) form input — a
+ * segmented reactive form field that lets the user pick an account by
+ * walking the MSCOA tree. Surfaces validation status via
+ * `TFormInputStatusComponent`.
+ *
+ * Inputs:
+ *  - `inputConfig: ITowerStepColumn` — required, descriptor for this MSCOA input.
+ *  - `editorMode: boolean` — default `false`; when `true`, renders in
+ *    builder-editor mode rather than user-facing mode.
+ *  - `formGroup: FormGroup` — required, the parent reactive form group that
+ *    owns this input's controls.
+ *  - `formBuilderFunctions: FormBuilderFunctions | undefined` — optional
+ *    builder hooks supplied when used inside the form builder.
+ *
+ * Outputs:
+ *  - `reload: void` — fires when the input requests its
+ *    container reload the underlying data (e.g., after a tree refresh).
+ */
+declare class MscoaFormInputComponent {
+    /** Descriptor for this MSCOA input. */
+    readonly inputConfig: _angular_core.InputSignal<ITowerStepColumn>;
+    /** When `true`, renders in builder-editor mode rather than user-facing mode. */
+    readonly editorMode: _angular_core.InputSignal<boolean>;
+    /** Parent reactive form group that owns this input's controls. */
+    readonly formGroup: _angular_core.InputSignal<FormGroup<any>>;
+    /** Optional builder hooks supplied when used inside the form builder. */
+    readonly formBuilderFunctions: _angular_core.InputSignal<FormBuilderFunctions | undefined>;
+    /** Fires when the input requests its container reload the underlying data. */
+    readonly reload: _angular_core.OutputEmitterRef<void>;
+    protected get errorMessage(): string | string[] | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MscoaFormInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MscoaFormInputComponent, "lib-mscoa-form-input", never, { "inputConfig": { "alias": "inputConfig"; "required": true; "isSignal": true; }; "editorMode": { "alias": "editorMode"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": true; "isSignal": true; }; "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; "isSignal": true; }; }, { "reload": "reload"; }, never, never, true, never>;
 }
 
-declare function assignDeepPropertyToObject(item: any, path: Array<string>, value: any): any;
+/**
+ * Form input that captures a hand-drawn signature via `SignaturePadInputComponent`
+ * and writes the resulting image to the bound `FormGroup` control. Surfaces
+ * validation state through `TFormInputStatusComponent`.
+ *
+ * Inputs:
+ *  - `inputConfig: ITowerStepColumn` — required, descriptor for this input.
+ *  - `formGroup: FormGroup` — required, the parent reactive form group.
+ *
+ * Outputs:
+ *  - `reload: void` — fires when the input requests its container reload
+ *    (e.g., after clearing the pad).
+ *
+ * @public
+ */
+declare class SignatureInputElementComponent {
+    readonly inputConfig: _angular_core.InputSignal<ITowerStepColumn>;
+    readonly formGroup: _angular_core.InputSignal<FormGroup<any>>;
+    readonly reload: _angular_core.OutputEmitterRef<void>;
+    protected readonly errorMessage: _angular_core.Signal<string | string[] | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SignatureInputElementComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SignatureInputElementComponent, "lib-signature-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": true; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": true; "isSignal": true; }; }, { "reload": "reload"; }, never, never, true, never>;
+}
 
 /**
- * Creates a file upload data object from a Base64 string.
+ * Builder-side editor for authoring a boolean expression (used for guarded
+ * navigation, conditional validation, and API path-selection rules). Validates
+ * the expression's syntax in real time and exposes the typed tree of value-
+ * access references the expression depends on.
  *
- * @param fileName The desired name for the file (e.g., 'my-image.png').
- * @param contentType The MIME type of the file (e.g., 'image/png').
- * @param base64Content The raw Base64 encoded content of the file.
- * @returns A populated FileUploadInputValueInterface object.
+ * Inputs:
+ *  - `hint: string` — helper text shown beneath the expression field.
+ *  - `label: string` — label for the expression field (default
+ *    `'Validation Expression'`).
+ *  - `formInputs: FormColumnInputs[]` — inputs the expression may reference.
+ *  - `data: unknown` — sample data used to test the expression.
+ *  - `expression: string` — initial expression string written into the editor
+ *    control.
+ *  - `valueAccessRules: Record<string, TreeNode[]>` — current value-access
+ *    tree for variables referenced by the expression.
+ *
+ * Outputs:
+ *  - `expressionChange` — fires when either the expression text or its derived
+ *    value-access tree changes.
+ *
+ * @public
+ * @deprecated Internal builder UI re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
  */
-declare const createFileFromBase64: (fileName: string, contentType: string, base64Content: string) => FileUploadInputValueInterface;
+declare class ValidationExpressioCreatorComponent {
+    #private;
+    /** Helper text shown beneath the expression field. */
+    readonly hint: _angular_core.InputSignal<string>;
+    /** Label for the expression field. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Inputs the expression may reference. */
+    readonly formInputs: _angular_core.InputSignal<FormColumnInputs[]>;
+    /** Sample data used to test the expression. Heterogeneous shape from parent template binding. */
+    readonly data: _angular_core.InputSignal<any>;
+    /** Initial expression string written into the editor control. */
+    readonly expression: _angular_core.InputSignal<string>;
+    /** Current value-access tree for variables referenced by the expression. */
+    readonly valueAccessRules: _angular_core.InputSignal<Record<string, TreeNode[]>>;
+    /** Fires when either the expression text or its derived value-access tree changes. */
+    readonly expressionChange: _angular_core.OutputEmitterRef<{
+        expression: string | null;
+        valueAccessRules: Record<string, TreeNode[]>;
+    }>;
+    protected readonly textareaElementRef: _angular_core.Signal<ElementRef<HTMLTextAreaElement>>;
+    protected readonly expressionControl: FormControl<string | null>;
+    protected readonly showSuggestions: _angular_core.WritableSignal<boolean>;
+    protected readonly optionsSearch: _angular_core.WritableSignal<string | undefined>;
+    protected readonly variableInEdit: _angular_core.WritableSignal<string | null>;
+    protected readonly methods: {
+        label: string;
+        hint: string;
+        value: string;
+    }[];
+    /** Bridge the `expression` input into the FormControl. */
+    protected readonly expressionBridge: _angular_core.EffectRef;
+    /** Mirror the `valueAccessRules` input into the local mutable copy. */
+    protected readonly valueAccessRulesBridge: _angular_core.EffectRef;
+    protected readonly valueAccessOptions: _angular_core.Signal<string[]>;
+    protected readonly allInputs: _angular_core.Signal<FormColumnInputs[]>;
+    constructor();
+    protected getMethods(): {
+        label: string;
+        hint: string;
+        value: string;
+    }[];
+    protected get errorMessage(): string | null;
+    protected getValueAccessRule(key: string): TreeNode[];
+    protected onTextChange(expression: string): Promise<void>;
+    protected cleanValueAccessRules(): void;
+    protected selectSuggestionInput(suggestion: string): void;
+    protected onFocus(): void;
+    protected toggleVariableInEdit(variable: string): void;
+    protected activeVariableChanged(value: TreeNode[] | string | {
+        [key: string]: TreeNode[] | string;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationExpressioCreatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValidationExpressioCreatorComponent, "lib-validation-expressio-creator", never, { "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "formInputs": { "alias": "formInputs"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "expression": { "alias": "expression"; "required": false; "isSignal": true; }; "valueAccessRules": { "alias": "valueAccessRules"; "required": false; "isSignal": true; }; }, { "expressionChange": "expressionChange"; }, never, never, true, never>;
+}
+
+/**
+ * Generic Material dialog shell used by the forms runtime to surface
+ * confirmation prompts and short-lived informational dialogs. Reads its
+ * configuration (title, body, button labels) from `MAT_DIALOG_DATA` as a
+ * `DialogConfig` and resolves its `MatDialogRef` with `true` when the user
+ * proceeds.
+ *
+ * Inputs:
+ *  - _None._ Configuration arrives through `MAT_DIALOG_DATA` (`DialogConfig`).
+ *
+ * Outputs:
+ *  - _None._ Result is delivered via `MatDialogRef.close(true)`.
+ *
+ * @public
+ * @deprecated Internal Material dialog template re-exported via the `_deprecated/`
+ *   compatibility barrel; remains functional. A renamed/improved replacement may be
+ *   introduced in a future minor; the original symbol stays callable. See
+ *   DECISIONS.md D-014.
+ */
+declare class DialogTemplateComponent {
+    readonly dialogRef: MatDialogRef<any, any>;
+    readonly data: DialogConfig;
+    proceed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogTemplateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogTemplateComponent, "lib-dialog-template", never, {}, {}, never, never, true, never>;
+}
 
-type DeepPropertyValue = any;
-type PropertyPath = (string | number | IArrayFunction[])[];
 /**
  * Custom error class for property access errors in deep object traversal.
  *
@@ -817,6 +1853,11 @@ type PropertyPath = (string | number | IArrayFunction[])[];
  *     console.log(`Error message: ${error.message}`);
  *   }
  * }
+ *
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
  */
 declare class PropertyAccessError extends Error {
     path: PropertyPath;
@@ -828,12 +1869,12 @@ declare class PropertyAccessError extends Error {
  *
  * @function returnDeepProperty
  *
- * @param {any} item - The object to traverse.
+ * @param {unknown} item - The object to traverse.
  * @param {(string|number|symbol)[]} path - An array representing the path to the desired property.
  *        Each element in the array can be a string (for object properties),
  *        a number (for array indices), or a symbol.
  *
- * @returns {any} The value of the deep property if it exists, otherwise undefined.
+ * @returns {DeepPropertyValue} The value of the deep property if it exists, otherwise undefined.
  *
  * @throws {Error} If the input item is null or undefined, or if the path is not a non-empty array.
  *
@@ -871,19 +1912,24 @@ declare class PropertyAccessError extends Error {
  * - Throws an error if the input item is null/undefined or if the path is invalid
  *
  * @see safeReturnDeepProperty for a version that never throws and returns an object with value and error properties
+ *
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
  */
-declare const returnDeepProperty: (item: any, path: PropertyPath) => DeepPropertyValue;
+declare const returnDeepProperty: (item: unknown, path: PropertyPath) => DeepPropertyValue;
 /**
  * Safely retrieves a deeply nested property from an object using a path array.
  *
  * @function safeReturnDeepProperty
  *
- * @param {any} item - The object to traverse.
+ * @param {unknown} item - The object to traverse.
  * @param {(string|number|symbol)[]} path - An array representing the path to the desired property.
  *        Each element in the array can be a string (for object properties),
  *        a number (for array indices), or a symbol.
  *
- * @returns {{value: any, error: string|null}} An object containing:
+ * @returns {{value: DeepPropertyValue, error: string|null}} An object containing:
  *          - value: The value of the deep property if found, otherwise undefined.
  *          - error: A string describing the error if one occurred, otherwise null.
  *
@@ -923,12 +1969,40 @@ declare const returnDeepProperty: (item: any, path: PropertyPath) => DeepPropert
  * - Implement error handling in a functional programming style
  *
  * @see returnDeepProperty for the core implementation that this function wraps
+ *
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
  */
-declare const safeReturnDeepProperty: (item: any, path: PropertyPath) => {
+declare const safeReturnDeepProperty: (item: unknown, path: PropertyPath) => {
     value: DeepPropertyValue;
     error: string | null;
 };
 
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare function assignDeepPropertyToObject(item: any, path: Array<string>, value: any): any;
+
+/**
+ * Creates a file upload data object from a Base64 string.
+ *
+ * @param fileName The desired name for the file (e.g., 'my-image.png').
+ * @param contentType The MIME type of the file (e.g., 'image/png').
+ * @param base64Content The raw Base64 encoded content of the file.
+ * @returns A populated FileUploadInputValueInterface object.
+ *
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare const createFileFromBase64: (fileName: string, contentType: string, base64Content: string) => FileUploadInputValueInterface;
+
 /**
  * Creates a sample value for a given form input configuration.
  * It determines the value based on the input's element type, specific input type (e.g., email, number),
@@ -936,13 +2010,46 @@ declare const safeReturnDeepProperty: (item: any, path: PropertyPath) => {
  *
  * @param {FormColumnInputs} input - The configuration object for the form input.
  * @returns {any} A sample value appropriate for the input type.
+ *
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
  */
 declare function getSampleValueForInput(input: FormColumnInputs): any;
 
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
 declare function getPipedValueFromDataType(dataType: InputDataTypes | undefined | DocumentLitsLabelConfigInterfaceValueType, value: any, pipe: FormColumnInputs['pipe'] | undefined): any;
 
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare const initFormConfigToV2: (formConfig: FormInterfaceMigration) => FormInterface;
+
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
 declare function getUrl(url: string, variables: NgxTFormsConfig): string;
 
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare const sheetConsolodation: (allSheets: Record<string, Record<string, any>[]>) => Record<string, any>[];
+
 /**
  * Validates an object against a validation expression.
  *
@@ -950,13 +2057,52 @@ declare function getUrl(url: string, variables: NgxTFormsConfig): string;
  * @param {object} object - The object to validate.
  * @returns {boolean} - A boolean indicating whether the object is valid according to the expression.
  *
- * This function is designed to handle a variety of cases for validating objects based on a given expression. It can:
- * 1. Evaluate an expression part with a single comparison operator, for example: 'a === 1' or '(a === 1)'.
- * 2. Evaluate an expression with multiple comparison operators, including: '===', '==', '!==', '!=', '>', '<', '>=', and '<='.
- * 3. Group expression parts considering bracket enclosures and logical operators.
- * 4. Evaluate an expression with multiple logical operators, such as 'a === 1 && b === 2 || c === 3'.
+ * Backed by the shared predicate evaluator ({@link evaluatePredicate}), a
+ * paren-aware, backward-compatible superset of the original space-split DSL. It
+ * supports `===`/`==`/`!==`/`!=`/`>`/`<`/`>=`/`<=`, `&&`/`||` with correct
+ * precedence and grouping, unary `!`, deep-path operands, multi-word quoted
+ * strings, the keyword operators `includes`/`in`/`startsWith`/`endsWith`/`matches`,
+ * and bare-operand truthiness.
+ */
+/**
+ * Public callers pass either a plain object (e.g. `{ age: 1 }`) or an array
+ * value (`item as T[]` from {@link evaluateArrayAccessRules}). Both are valid
+ * index containers for the DSL (arrays support `length`, numeric indices, and
+ * the `in` operator on string keys), so accept `object` and narrow internally.
+ */
+type ValidationTarget = object;
+/**
+ * Validates an object against a predicate expression. Delegates to the shared,
+ * paren-aware predicate evaluator (a backward-compatible superset of the
+ * original space-split DSL). Throws on a structurally invalid expression.
+ */
+declare const validateObjectAgainstString: (expression: string, object: ValidationTarget) => boolean;
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
  */
-declare const validateObjectAgainstString: (expression: string, object: any) => boolean;
 declare function validateExpressionSyntax(expression: string): string | null;
 
-export { DialogTemplateComponent, FORM_ACTIONS_TOKEN, FORM_CONFIG_TOKEN, FORM_INPUTS_TOKEN, FORM_SLIDES_TOKEN, FormBuilderComponent, FormTowerControllerService, FormatDataPipe, FormsComponent, MSCOA_TREE_PROVIDER, MULTIPLE_FORM_INPUT_TOKEN, MscoaFormInputComponent, NGX_T_FORMS_CONFIG_TOKEN, NgxTFormsComponent, NgxTFormsService, PropertyAccessError, SignatureInputElementComponent, TDynamicDataEditComponent, TDynamicDataViewComponent, TFormInputComponent, UTILS_OBJECT_TOKEN, UserFormStepperComponent, ValidationExpressioCreatorComponent, assignDeepPropertyToObject, createFileFromBase64, formGenerator, getPipedValueFromDataType, getSampleValueForInput, getSectionElements, getSignatureImage, getUrl, getValueFromValueAccessor, initFormConfigToV2, provideNgxTForms, returnDeepProperty, returnMappedPathValue, safeReturnDeepProperty, testAgainstItem, textIconsForUserHints, validateExpressionSyntax, validateObjectAgainstString };
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ */
+declare function testAgainstItem(test: ConfigurationValidTestInterface, item: unknown): boolean;
+
+/**
+ * @public
+ * @deprecated Internal helper re-exported via the `_deprecated/` compatibility
+ *   barrel; remains functional. A renamed/improved replacement may be introduced
+ *   in a future minor; the original symbol stays callable. See DECISIONS.md D-014.
+ *
+ *   **Breaking (v2.x):** now requires `secret` as a third argument — the
+ *   hardcoded library secret was removed (LIB-05). Read it from
+ *   `INPUT_SECRET_TOKEN` in your component / service before calling.
+ */
+declare const getSignatureImage: (inputConfig: FormColumnInputs, value: EncryptedData | undefined, secret: string) => Promise<string | undefined>;
+
+export { DialogTemplateComponent, FORM_ACTIONS_TOKEN, FORM_CONFIG_TOKEN, FORM_INPUTS_TOKEN, FORM_ROUTE_SOURCE, FORM_SLIDES_TOKEN, FormBuilderComponent, FormTowerControllerService, FormatDataPipe, FormsComponent, HttpPipelineRepository, IMPORT_TOWER_INSTANCE_ID, INPUT_SECRET_TOKEN, MSCOA_TREE_PROVIDER, MULTIPLE_FORM_INPUT_TOKEN, MscoaFormInputComponent, NGX_T_FORMS_CONFIG_TOKEN, NgxTFormsComponent, NgxTFormsService, PIPELINE_REPOSITORY, PipelineRepository, PropertyAccessError, SignatureInputElementComponent, TDynamicDataEditComponent, TDynamicDataViewComponent, TFormImportController, TFormInputComponent, UTILS_OBJECT_TOKEN, UserFormStepperComponent, ValidationExpressioCreatorComponent, assignDeepPropertyToObject, createFileFromBase64, formGenerator, getPipedValueFromDataType, getSampleValueForInput, getSectionElements, getSignatureImage, getUrl, getValueFromValueAccessor, initFormConfigToV2, provideNgxTForms, returnDeepProperty, returnMappedPathValue, safeReturnDeepProperty, sheetConsolodation, testAgainstItem, textIconsForUserHints, validateExpressionSyntax, validateObjectAgainstString, withHttpPipeline, withInputSecret, withRouterFormId };