@frame-kit/ui-ng 0.0.1

package/types/frame-kit-ui-ng-forms.d.ts

@@ -0,0 +1,1674 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Type, OnInit, ElementRef, TemplateRef } from '@angular/core';
+import { NgControl, AsyncValidatorFn, ValidatorFn, AbstractControl, FormArray, FormGroup, FormControl, ControlValueAccessor } from '@angular/forms';
+import { IconSize, IconColor } from '@frame-kit/ui-ng/core/icon';
+
+declare class ErrorComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Stable element ID wired to the field's aria-describedby. */
+    readonly id: _angular_core.InputSignal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostId(): string;
+    get hostRole(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ErrorComponent, "fk-error", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type FieldGroupLayout = 'stack' | 'inline';
+
+declare class FieldGroupComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Optional group label rendered as a fieldset legend. */
+    readonly label: _angular_core.InputSignal<string | null>;
+    /** Layout direction for child fields. */
+    readonly layout: _angular_core.InputSignal<FieldGroupLayout>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldGroupComponent, "fk-field-group", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Submission status for the form lifecycle.
+ */
+type FormStatus = 'idle' | 'submitting' | 'success' | 'error';
+
+/**
+ * Token that child fk-form-field components can inject to read
+ * the form's submitted state.
+ */
+declare const FORM: InjectionToken<FormComponent>;
+declare class FormComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Whether the form has been submitted at least once. */
+    readonly submitted: _angular_core.WritableSignal<boolean>;
+    /** Current submission status. */
+    readonly status: _angular_core.WritableSignal<FormStatus>;
+    /** Derived convenience signals. */
+    readonly isSubmitting: _angular_core.Signal<boolean>;
+    readonly isSuccess: _angular_core.Signal<boolean>;
+    readonly isError: _angular_core.Signal<boolean>;
+    readonly isIdle: _angular_core.Signal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    /** Emits when the form is submitted. */
+    readonly formSubmit: _angular_core.OutputEmitterRef<void>;
+    onSubmit(): void;
+    /**
+     * Sets the form status to 'submitting'.
+     * Call this before starting an async submission.
+     */
+    startSubmitting(): void;
+    /**
+     * Sets the form status to 'success'.
+     * Call this when the submission succeeds.
+     */
+    setSuccess(): void;
+    /**
+     * Sets the form status to 'error'.
+     * Call this when the submission fails.
+     */
+    setError(): void;
+    /** Resets the submitted state and status to idle. */
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormComponent, "fk-form", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; }, { "formSubmit": "formSubmit"; }, never, ["*"], true, never>;
+}
+
+interface FieldControl {
+    /** Stable ID for the control element. */
+    id: string;
+    /** IDs currently set as aria-describedby on the control. */
+    describedByIds: string[];
+    /** Whether the control is currently focused. */
+    focused: boolean;
+    /** Whether the control has no value. */
+    empty: boolean;
+    /** Whether the control is disabled. */
+    disabled: boolean;
+    /** Whether the control is required. */
+    required: boolean;
+    /** Whether the control is readonly. */
+    readonly?: boolean;
+    /** Reference to the NgControl, if bound. */
+    ngControl: NgControl | null;
+    /** Called by fk-form-field to push composed described-by IDs down to the control. */
+    setDescribedByIds(ids: string[]): void;
+    /** Called when the wrapper container is clicked (forwards focus to custom controls). */
+    onContainerClick?(event: MouseEvent): void;
+}
+declare const FIELD_CONTROL: InjectionToken<FieldControl>;
+
+/**
+ * Configuration for a single validator, used by the schema engine
+ * and validation registry.
+ */
+interface ValidatorConfig {
+    /** Validator type key (e.g. 'required', 'minLength', 'email'). */
+    type: string;
+    /** Parameter value for parameterized validators (e.g. 3 for minLength). */
+    value?: unknown;
+    /** Custom error message override for this validator. */
+    message?: string;
+}
+/**
+ * Configuration for an async validator.
+ */
+interface AsyncValidatorConfig {
+    /** Async validator type key. */
+    type: string;
+    /** Parameter value for the async validator. */
+    value?: unknown;
+    /** Custom error message override. */
+    message?: string;
+}
+/**
+ * A factory that creates a ValidatorFn, optionally parameterized.
+ */
+type ValidatorFactory = (value?: unknown) => ValidatorFn;
+/**
+ * A factory that creates an AsyncValidatorFn, optionally parameterized.
+ */
+type AsyncValidatorFactory = (value?: unknown) => AsyncValidatorFn;
+/**
+ * Map of error keys to human-readable message templates.
+ * Templates may contain `{key}` placeholders for interpolation.
+ *
+ * @example
+ * ```ts
+ * const messages: ErrorMessages = {
+ *   required: 'This field is required',
+ *   minlength: 'Must be at least {requiredLength} characters',
+ *   email: 'Please enter a valid email address',
+ * };
+ * ```
+ */
+type ErrorMessages = Record<string, string>;
+
+declare class HintComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Stable element ID wired to the field's aria-describedby. */
+    readonly id: _angular_core.InputSignal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostId(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HintComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HintComponent, "fk-hint", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class LabelComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Stable element ID used to reference this label from other elements. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** ID of the form control this label describes; renders as the `for` attribute. */
+    readonly for: _angular_core.InputSignal<string | null>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostId(): string;
+    get hostFor(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabelComponent, "fk-label", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "for": { "alias": "for"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type ShowErrorsOn = 'touched' | 'dirty' | 'submit';
+
+declare const FK_PREFIX: InjectionToken<FkPrefixDirective>;
+declare class FkPrefixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FkPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FkPrefixDirective, "[fkPrefix]", never, {}, {}, never, never, true, never>;
+}
+
+declare const FK_SUFFIX: InjectionToken<FkSuffixDirective>;
+declare class FkSuffixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FkSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FkSuffixDirective, "[fkSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FormFieldComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Text label rendered above the field; forwarded to the projected fk-label when present. */
+    readonly label: _angular_core.InputSignal<string | null>;
+    /** Condition under which validation errors are displayed. */
+    readonly showErrorsOn: _angular_core.InputSignal<ShowErrorsOn>;
+    /** Whether the parent form has been submitted; used when showErrorsOn is "submit". */
+    readonly submitted: _angular_core.InputSignal<boolean>;
+    /** Additional aria-describedby ID to append to the field's accessibility wiring. */
+    readonly externalDescribedBy: _angular_core.InputSignal<string | null>;
+    /**
+     * Fallback AbstractControl for dynamically created fields
+     * where NgControl is not available.
+     */
+    readonly fallbackControl: _angular_core.InputSignal<AbstractControl<any, any, any> | null>;
+    /**
+     * Per-field error message overrides.
+     * Keys are validation error keys (e.g. 'required', 'minlength').
+     * Values are message templates supporting `{key}` interpolation.
+     *
+     * When provided, these take priority over global error messages.
+     * When neither field-level nor global messages are provided for
+     * an error key, the key itself is used as the message.
+     */
+    readonly errorMessages: _angular_core.InputSignal<ErrorMessages | null>;
+    readonly control: _angular_core.Signal<FieldControl | undefined>;
+    readonly hintRef: _angular_core.Signal<HintComponent | undefined>;
+    readonly errorRef: _angular_core.Signal<ErrorComponent | undefined>;
+    readonly labelRef: _angular_core.Signal<LabelComponent | undefined>;
+    readonly prefixRef: _angular_core.Signal<FkPrefixDirective | undefined>;
+    readonly suffixRef: _angular_core.Signal<FkSuffixDirective | undefined>;
+    private readonly globalErrorMessages;
+    private readonly cdr;
+    get hostClass(): string;
+    readonly fieldId: string;
+    readonly labelId: string;
+    readonly autoErrorId: string;
+    /**
+     * Whether this field uses auto error messages (no projected fk-error).
+     */
+    get hasAutoError(): boolean;
+    /**
+     * Resolves the AbstractControl to use for validation checks.
+     * Prefers NgControl from the projected FieldControl, falls back
+     * to the explicitly provided AbstractControl (for dynamic fields).
+     */
+    private resolveControl;
+    /** Returns true when the field's validation error should be displayed. */
+    showError(): boolean;
+    /**
+     * Resolves the auto error message from the control's validation errors.
+     * Uses field-level overrides first, then global messages, then the error key.
+     */
+    autoErrorMessage(): string | null;
+    /** Returns true when the projected field control currently has focus. */
+    isFocused(): boolean;
+    /** Returns true when the projected field control has no value. */
+    isEmpty(): boolean;
+    /** Returns true when the projected field control is disabled. */
+    isDisabled(): boolean;
+    /** Returns true when the field is marked required by the control or validator. */
+    isRequired(): boolean;
+    /** Returns true when the projected field control is read-only. */
+    isReadonly(): boolean;
+    /** Returns true when the field is in an invalid state that should be shown. */
+    isInvalid(): boolean;
+    constructor();
+    private syncDescribedByIds;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldComponent, "fk-form-field", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showErrorsOn": { "alias": "showErrorsOn"; "required": false; "isSignal": true; }; "submitted": { "alias": "submitted"; "required": false; "isSignal": true; }; "externalDescribedBy": { "alias": "externalDescribedBy"; "required": false; "isSignal": true; }; "fallbackControl": { "alias": "fallbackControl"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; }, {}, ["control", "hintRef", "errorRef", "labelRef", "prefixRef", "suffixRef"], ["fk-label", "[fkPrefix]", "*", "[fkSuffix]", "fk-error", "fk-hint"], true, never>;
+}
+
+/**
+ * Option for select, radio, and multi-select controls.
+ */
+interface Option {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+/**
+ * UI configuration for a field rendered via schema.
+ */
+/**
+ * Configuration for an inline link rendered at the end of a field's label row.
+ */
+interface LabelEndLink {
+    /** Display text for the link. */
+    text: string;
+    /** Angular router link target. */
+    route: string;
+}
+/**
+ * UI configuration for a field rendered via schema.
+ */
+interface FieldUiConfig {
+    appearance?: 'default' | 'quiet';
+    size?: 'sm' | 'md' | 'lg';
+    width?: string;
+    hint?: string;
+    prefixIcon?: string;
+    suffixIcon?: string;
+    /** Optional link rendered on the right side of the field's label row. */
+    labelEndLink?: LabelEndLink;
+}
+/**
+ * Rule for conditional field visibility.
+ *
+ * @example
+ * ```ts
+ * visibleWhen: { field: 'country', equals: 'US' }
+ * visibleWhen: { field: 'age', notEquals: '' }
+ * ```
+ */
+interface VisibilityRule {
+    /** Key of the field to observe. */
+    field: string;
+    /** Show this field when the observed field equals this value. */
+    equals?: unknown;
+    /** Show this field when the observed field does NOT equal this value. */
+    notEquals?: unknown;
+}
+/**
+ * Schema definition for a single form field.
+ */
+interface FieldSchema {
+    /** Unique key for the form control (maps to FormGroup control name). */
+    key: string;
+    /** Field type key (must be registered in FieldRegistry). */
+    type: string;
+    /** Label text displayed above the field. */
+    label?: string;
+    /** Description text (currently unused, reserved for future layout). */
+    description?: string;
+    /** Placeholder text for the control. */
+    placeholder?: string;
+    /**
+     * Native `autocomplete` attribute token (e.g. "username", "email",
+     * "current-password", "new-password"). Forwarded to controls that
+     * accept an `autocomplete` input (fk-input, fk-password-input).
+     */
+    autocomplete?: string;
+    /** Default value for the control. */
+    defaultValue?: unknown;
+    /** Whether the control starts disabled. */
+    disabled?: boolean;
+    /** Whether the control is readonly. */
+    readonly?: boolean;
+    /** Whether the field is required (adds Validators.required automatically). */
+    required?: boolean;
+    /** Synchronous validator configurations. */
+    validators?: ValidatorConfig[];
+    /** Async validator configurations. */
+    asyncValidators?: AsyncValidatorConfig[];
+    /** Options for select, radio, multi-select controls. */
+    options?: Option[];
+    /** UI display configuration. */
+    ui?: FieldUiConfig;
+    /** Conditional visibility rule. */
+    visibleWhen?: VisibilityRule;
+    /** Per-field error message overrides. */
+    errorMessages?: Record<string, string>;
+    /**
+     * Child fields for nested FormGroups.
+     * When set, this field creates a nested FormGroup instead of a FormControl.
+     */
+    children?: FieldSchema[];
+    /**
+     * Field definitions for a FormArray.
+     * When set, this field creates a FormArray of FormGroups.
+     * Each row is a FormGroup built from these field definitions.
+     */
+    arrayFields?: FieldSchema[];
+    /** Minimum number of rows for field arrays. */
+    minRows?: number;
+    /** Maximum number of rows for field arrays. */
+    maxRows?: number;
+}
+/**
+ * Layout column definition for responsive form layouts.
+ */
+interface LayoutColumn {
+    /** Field key to render in this column. */
+    fieldKey: string;
+    /** Column span (1-12 grid). */
+    span?: number;
+}
+/**
+ * Layout row definition (one or more columns).
+ */
+interface LayoutRow {
+    /** Columns in this row. */
+    columns: LayoutColumn[];
+}
+/**
+ * A section groups related fields with an optional heading.
+ */
+interface FormSchemaSection {
+    /** Section heading. */
+    title?: string;
+    /** Optional description below the heading. */
+    description?: string;
+    /** Fields in this section. */
+    fields: FieldSchema[];
+    /** Optional layout rows for this section. */
+    layout?: LayoutRow[];
+}
+/**
+ * Schema definition for a complete form.
+ */
+interface FormSchema {
+    /** Array of field definitions (flat fields at the top level). */
+    fields: FieldSchema[];
+    /** Optional sections for organized layout. */
+    sections?: FormSchemaSection[];
+    /** Optional top-level layout rows (for flat fields). */
+    layout?: LayoutRow[];
+}
+
+/**
+ * Renders a FormArray as repeatable rows of fields.
+ *
+ * Each row is a FormGroup built from the field's `arrayFields` definition.
+ * Provides add/remove row functionality with min/max constraints.
+ *
+ * @example
+ * ```html
+ * <fk-field-array-outlet
+ *   [field]="phoneNumbersField"
+ *   [formArray]="form.get('phones') as FormArray"
+ *   [submitted]="submitted()"
+ * />
+ * ```
+ */
+declare class FieldArrayOutletComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Schema definition for the repeating field, including arrayFields and row constraints. */
+    readonly field: _angular_core.InputSignal<FieldSchema>;
+    /** The FormArray backing the repeatable rows. */
+    readonly formArray: _angular_core.InputSignal<FormArray<any>>;
+    /** Whether the parent form has been submitted; propagated to each fk-field-outlet. */
+    readonly submitted: _angular_core.InputSignal<boolean>;
+    /** Fires with the index of the newly added row. */
+    readonly rowAdded: _angular_core.OutputEmitterRef<number>;
+    /** Fires with the index of the removed row. */
+    readonly rowRemoved: _angular_core.OutputEmitterRef<number>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    private readonly schemaParser;
+    /** Returns the current FormGroups for each rendered row. */
+    rows(): FormGroup[];
+    /** Returns true when another row can be added without exceeding maxRows. */
+    canAdd(): boolean;
+    /** Returns true when a row can be removed without going below minRows. */
+    canRemove(): boolean;
+    /** Appends a new blank row to the FormArray. */
+    addRow(): void;
+    /** Removes the row at the given index from the FormArray. */
+    removeRow(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldArrayOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldArrayOutletComponent, "fk-field-array-outlet", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": true; "isSignal": true; }; "formArray": { "alias": "formArray"; "required": true; "isSignal": true; }; "submitted": { "alias": "submitted"; "required": false; "isSignal": true; }; }, { "rowAdded": "rowAdded"; "rowRemoved": "rowRemoved"; }, never, never, true, never>;
+}
+
+/**
+ * Dynamically renders a single field from a schema definition.
+ *
+ * Wraps the control in a `fk-form-field` for consistent layout,
+ * accessibility, and error handling. Uses `ViewContainerRef` to
+ * instantiate the appropriate control component from the field registry.
+ *
+ * @example
+ * ```html
+ * <fk-field-outlet
+ *   [field]="fieldSchema"
+ *   [form]="formGroup"
+ *   [submitted]="submitted()"
+ * />
+ * ```
+ */
+declare class FieldOutletComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Schema definition for the field to render. */
+    readonly field: _angular_core.InputSignal<FieldSchema>;
+    /** Parent FormGroup used to bind the field's reactive control. */
+    readonly form: _angular_core.InputSignal<FormGroup<any>>;
+    /** Whether the parent form has been submitted; propagated to fk-form-field. */
+    readonly submitted: _angular_core.InputSignal<boolean>;
+    /** Whether this field is visible (for conditional visibility). */
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostDisplay(): "" | "none";
+    private readonly fieldRegistry;
+    private readonly destroyRef;
+    private readonly controlHostRef;
+    /** Track what was last rendered to avoid unnecessary re-creation. */
+    private renderedField;
+    private renderedForm;
+    private renderedType;
+    /** Subscription to statusChanges for disabled sync — cleaned up on re-render. */
+    private statusSub;
+    /** Resolved component type from the registry. */
+    readonly componentType: _angular_core.Signal<Type<any>>;
+    constructor();
+    private renderControl;
+    private setupVisibility;
+    private evaluateVisibility;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldOutletComponent, "fk-field-outlet", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "submitted": { "alias": "submitted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a complete form from a schema definition.
+ *
+ * Generates a FormGroup from the schema, wraps it in a `fk-form`,
+ * and renders each field via `fk-field-outlet`. Supports layout
+ * sections for organized field grouping.
+ *
+ * @example
+ * ```ts
+ * schema: FormSchema = {
+ *   fields: [
+ *     { key: 'email', type: 'input', label: 'Email', required: true },
+ *     { key: 'password', type: 'password', label: 'Password', required: true },
+ *   ],
+ * };
+ * ```
+ *
+ * ```html
+ * <fk-form-renderer
+ *   [schema]="schema"
+ *   (formSubmit)="onSubmit($event)"
+ * />
+ * ```
+ */
+declare class FormRendererComponent implements OnInit {
+    readonly className: _angular_core.InputSignal<string>;
+    /** The form schema to render. */
+    readonly schema: _angular_core.InputSignal<FormSchema>;
+    /**
+     * Optional externally provided FormGroup.
+     * If not provided, one is auto-generated from the schema.
+     */
+    readonly form: _angular_core.InputSignal<FormGroup<any> | null>;
+    /** Emits the FormGroup value when the form is submitted. */
+    readonly formSubmit: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    /** The resolved FormGroup (either provided or auto-generated). */
+    readonly resolvedForm: _angular_core.WritableSignal<FormGroup<any> | null>;
+    /** Reference to the inner fk-form for submission state. */
+    readonly formRef: _angular_core.WritableSignal<FormComponent | null>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    private readonly schemaParser;
+    private readonly el;
+    ngOnInit(): void;
+    /** Looks up a schema field definition by its key. */
+    getField(key: string): FormSchema['fields'][number] | undefined;
+    /** Returns the FormArray for a repeating field at the given key. */
+    getFormArray(key: string): FormArray;
+    onFormSubmit(): void;
+    /**
+     * Finds the first invalid field in schema order and focuses its input.
+     * Call this after markAllAsTouched() to direct the user to the first error.
+     */
+    focusFirstInvalidField(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormRendererComponent, "fk-form-renderer", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; }, { "formSubmit": "formSubmit"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Public types for `fk-form-renderer`.
+ *
+ * The renderer is a thin presentation layer over the schema engine —
+ * its public type contract is the engine's schema vocabulary
+ * (`FormSchema`, `FieldSchema`, `FieldUiConfig`, `Option`, etc.) plus
+ * the runtime emit shape. Re-exporting from here gives consumers a
+ * single discoverable surface (`@frame-kit/ui-ng`) without forcing them
+ * to know which layer the types live in.
+ */
+
+/**
+ * Shape emitted by `(formSubmit)` — the form's raw value keyed by
+ * field key. Cast to a more specific shape at the consumer when the
+ * schema is known statically.
+ */
+type FormRendererSubmitValue = Record<string, unknown>;
+
+/**
+ * Renders a form section with an optional title, description,
+ * and layout-aware field rendering.
+ *
+ * @example
+ * ```html
+ * <fk-section-outlet
+ *   [section]="section"
+ *   [form]="formGroup"
+ *   [submitted]="submitted()"
+ * />
+ * ```
+ */
+declare class SectionOutletComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Schema section definition including its title, description, and field list. */
+    readonly section: _angular_core.InputSignal<FormSchemaSection>;
+    /** Parent FormGroup used to bind each field's reactive control. */
+    readonly form: _angular_core.InputSignal<FormGroup<any>>;
+    /** Whether the parent form has been submitted; propagated to each fk-field-outlet. */
+    readonly submitted: _angular_core.InputSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    /** Looks up a field definition within this section by its key. */
+    getField(key: string): FormSchemaSection['fields'][number] | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SectionOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SectionOutletComponent, "fk-section-outlet", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "section": { "alias": "section"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "submitted": { "alias": "submitted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FormSectionComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    /** Section heading. */
+    readonly title: _angular_core.InputSignal<string | null>;
+    /** Optional description below the heading. */
+    readonly description: _angular_core.InputSignal<string | null>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormSectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormSectionComponent, "fk-form-section", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Default error messages for common Angular validators.
+ *
+ * Keys match the error keys emitted by Angular's built-in Validators
+ * (lowercase: 'required', 'minlength', 'maxlength', 'email', 'min', 'max', 'pattern').
+ *
+ * Templates use `{key}` syntax for interpolation with the validation
+ * error object properties.
+ */
+declare const DEFAULT_ERROR_MESSAGES: ErrorMessages;
+/**
+ * Injection token for providing custom error messages.
+ *
+ * Provide at the root or module level to override default messages globally,
+ * or at a component level for scoped overrides.
+ *
+ * @example
+ * ```ts
+ * providers: [
+ *   {
+ *     provide: ERROR_MESSAGES,
+ *     useValue: {
+ *       required: 'Required',
+ *       email: 'Invalid email',
+ *     },
+ *   },
+ * ]
+ * ```
+ */
+declare const ERROR_MESSAGES: InjectionToken<ErrorMessages>;
+/**
+ * Interpolates a message template with values from a validation error object.
+ *
+ * Replaces `{key}` placeholders with corresponding values from the error details.
+ *
+ * @example
+ * ```ts
+ * interpolateMessage('Must be at least {requiredLength} characters', { requiredLength: 3 });
+ * // => 'Must be at least 3 characters'
+ * ```
+ */
+declare function interpolateMessage(template: string, errorValue: Record<string, unknown>): string;
+/**
+ * Resolves the first error message for a control's current validation errors.
+ *
+ * Resolution order:
+ * 1. Field-level overrides (`fieldMessages`)
+ * 2. Global messages (injected via `ERROR_MESSAGES`)
+ * 3. Falls back to the error key itself
+ *
+ * @param errors - The validation errors object from `AbstractControl.errors`
+ * @param globalMessages - Global error message map
+ * @param fieldMessages - Per-field error message overrides
+ * @returns The resolved, interpolated error message, or `null` if no errors
+ */
+declare function resolveErrorMessage(errors: Record<string, unknown> | null, globalMessages: ErrorMessages, fieldMessages?: ErrorMessages): string | null;
+
+/**
+ * Registry that maps field type strings to Angular component classes.
+ *
+ * Built-in field types are registered by default. Custom field types
+ * can be registered at any time to extend the schema engine.
+ *
+ * @example
+ * ```ts
+ * // Register a custom field type
+ * registry.register('currency', CurrencyInputComponent);
+ *
+ * // Use in schema
+ * { key: 'price', type: 'currency', label: 'Price' }
+ * ```
+ */
+declare class FieldRegistry {
+    private readonly components;
+    constructor();
+    /**
+     * Registers a component class for a field type key.
+     */
+    register(type: string, component: Type<any>): void;
+    /**
+     * Returns the component class for a field type key.
+     *
+     * @throws Error if the type is not registered
+     */
+    get(type: string): Type<any>;
+    /**
+     * Checks if a field type is registered.
+     */
+    has(type: string): boolean;
+    private registerDefaults;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FieldRegistry>;
+}
+
+/**
+ * Snapshot of a single field's state.
+ */
+interface FieldState {
+    touched: boolean;
+    dirty: boolean;
+    invalid: boolean;
+    valid: boolean;
+    pending: boolean;
+    disabled: boolean;
+    enabled: boolean;
+    pristine: boolean;
+    untouched: boolean;
+    errors: Record<string, unknown> | null;
+    value: unknown;
+}
+/**
+ * Returns a snapshot of a control's state.
+ *
+ * @example
+ * ```ts
+ * const state = getFieldState(form.get('email'));
+ * if (state.invalid && state.touched) {
+ *   // show error
+ * }
+ * ```
+ */
+declare function getFieldState(control: AbstractControl | null): FieldState | null;
+/**
+ * Returns whether a control has a specific validation error.
+ *
+ * @example
+ * ```ts
+ * if (hasError(form.get('email'), 'required')) {
+ *   // ...
+ * }
+ * ```
+ */
+declare function hasError(control: AbstractControl | null, errorKey: string): boolean;
+/**
+ * Returns the error value for a specific validation error key.
+ *
+ * @example
+ * ```ts
+ * const minErr = getError(form.get('age'), 'min');
+ * // { min: 18, actual: 12 }
+ * ```
+ */
+declare function getError(control: AbstractControl | null, errorKey: string): unknown | null;
+/**
+ * Marks all controls in a FormGroup as touched.
+ * Useful for triggering validation display on form submission.
+ *
+ * @example
+ * ```ts
+ * if (form.invalid) {
+ *   markAllTouched(form);
+ *   return;
+ * }
+ * ```
+ */
+declare function markAllTouched(group: FormGroup): void;
+/**
+ * Returns whether all controls in a FormGroup are valid.
+ */
+declare function isFormValid(group: FormGroup): boolean;
+/**
+ * Returns all invalid control keys in a FormGroup (top-level only).
+ *
+ * @example
+ * ```ts
+ * const invalid = getInvalidFields(form);
+ * // ['email', 'password']
+ * ```
+ */
+declare function getInvalidFields(group: FormGroup): string[];
+
+/**
+ * Parses a FormSchema into an Angular FormGroup.
+ *
+ * Resolves validators from the validation registry and applies
+ * default values, disabled state, and required constraints.
+ *
+ * @example
+ * ```ts
+ * const schema: FormSchema = {
+ *   fields: [
+ *     { key: 'email', type: 'input', required: true, validators: [{ type: 'email' }] },
+ *     { key: 'name', type: 'input', defaultValue: 'John' },
+ *   ],
+ * };
+ *
+ * const form = parser.buildFormGroup(schema);
+ * // form.get('email') => FormControl with required + email validators
+ * // form.get('name') => FormControl with value 'John'
+ * ```
+ */
+declare class SchemaParser {
+    private readonly validationRegistry;
+    /**
+     * Builds a FormGroup from a form schema.
+     *
+     * Supports flat fields, nested groups (via `children`),
+     * field arrays (via `arrayFields`), and layout sections.
+     */
+    buildFormGroup(schema: FormSchema): FormGroup;
+    /**
+     * Builds a single FormControl from a field schema.
+     */
+    buildControl(field: FieldSchema): FormControl;
+    /**
+     * Builds a nested FormGroup from a field with `children`.
+     */
+    buildNestedGroup(field: FieldSchema): FormGroup;
+    /**
+     * Builds a FormArray from a field with `arrayFields`.
+     *
+     * Creates one initial row from the array field definitions.
+     * Additional rows can be added programmatically.
+     */
+    buildFieldArray(field: FieldSchema): FormArray;
+    /**
+     * Creates a new row FormGroup for a field array.
+     */
+    buildArrayRow(field: FieldSchema): FormGroup;
+    private buildGroupFromFields;
+    /**
+     * Collects all fields from a schema, including fields
+     * within layout sections.
+     */
+    private collectFields;
+    private resolveValidators;
+    private resolveAsyncValidators;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SchemaParser, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SchemaParser>;
+}
+
+/**
+ * Registry that maps validator type names to factory functions.
+ *
+ * Built-in validators (required, minLength, maxLength, email, min, max, pattern)
+ * are registered by default. Custom validators can be registered at any time.
+ *
+ * Used by the schema engine (Phase 3) to create ValidatorFn arrays from
+ * schema configurations, and available for programmatic use.
+ *
+ * @example
+ * ```ts
+ * // Register a custom validator
+ * registry.register('phone', () =>
+ *   Validators.pattern(/^\+?[\d\s-]{10,}$/)
+ * );
+ *
+ * // Resolve validators from config
+ * const validators = registry.resolve([
+ *   { type: 'required' },
+ *   { type: 'minLength', value: 3 },
+ *   { type: 'phone' },
+ * ]);
+ * ```
+ */
+declare class ValidationRegistry {
+    private readonly validators;
+    private readonly asyncValidators;
+    constructor();
+    /**
+     * Registers a synchronous validator factory.
+     *
+     * @param type - The validator type key
+     * @param factory - Factory function that creates a ValidatorFn
+     */
+    register(type: string, factory: ValidatorFactory): void;
+    /**
+     * Registers an asynchronous validator factory.
+     *
+     * @param type - The async validator type key
+     * @param factory - Factory function that creates an AsyncValidatorFn
+     */
+    registerAsync(type: string, factory: AsyncValidatorFactory): void;
+    /**
+     * Checks if a synchronous validator type is registered.
+     */
+    has(type: string): boolean;
+    /**
+     * Checks if an asynchronous validator type is registered.
+     */
+    hasAsync(type: string): boolean;
+    /**
+     * Resolves an array of validator configs into ValidatorFn instances.
+     *
+     * @throws Error if a validator type is not registered
+     */
+    resolve(configs: ValidatorConfig[]): ValidatorFn[];
+    /**
+     * Resolves an array of async validator configs into AsyncValidatorFn instances.
+     *
+     * @throws Error if an async validator type is not registered
+     */
+    resolveAsync(configs: AsyncValidatorConfig[]): AsyncValidatorFn[];
+    private registerDefaults;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ValidationRegistry>;
+}
+
+interface AutocompleteOption<T = unknown> {
+    label: string;
+    value: string | number;
+    data?: T;
+}
+type AutocompleteFilterMode = 'local' | 'manual';
+
+declare const FK_AUTOCOMPLETE_OPTION_TPL: InjectionToken<FkAutocompleteOptionTplDirective>;
+declare class FkAutocompleteOptionTplDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FkAutocompleteOptionTplDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FkAutocompleteOptionTplDirective, "[fkAutocompleteOption]", never, {}, {}, never, never, true, never>;
+}
+declare class AutocompleteComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** Placeholder text shown in the text input when no value is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    /** List of selectable options rendered in the dropdown. */
+    readonly options: _angular_core.InputSignal<AutocompleteOption<unknown>[]>;
+    /**
+     * 'local' (default): filters options client-side.
+     * 'manual': skips internal filtering — renders options as-is.
+     *           Use with searchChange output for server-side search.
+     */
+    readonly filterMode: _angular_core.InputSignal<AutocompleteFilterMode>;
+    /** Whether async options are currently loading. */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /**
+     * Emits the current input value on each keystroke.
+     * Use in manual filterMode for server-side search.
+     */
+    readonly searchChange: _angular_core.OutputEmitterRef<string>;
+    /** Custom template for rendering each option in the dropdown. */
+    readonly optionTpl: _angular_core.Signal<FkAutocompleteOptionTplDirective | undefined>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly showDropdown: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    readonly filteredOptions: _angular_core.WritableSignal<AutocompleteOption<unknown>[]>;
+    readonly activeIndex: _angular_core.WritableSignal<number>;
+    /** The options to render in the dropdown — filtered or raw depending on mode. */
+    readonly visibleOptions: _angular_core.Signal<AutocompleteOption<unknown>[]>;
+    private displayValue;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private selectedValue;
+    private onChange;
+    private onTouched;
+    writeValue(value: string | number | null): void;
+    registerOnChange(fn: (value: string | number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Commits the given option as the selected value and closes the dropdown. */
+    selectOption(option: AutocompleteOption): void;
+    private filterOptions;
+    onInput(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteComponent, "fk-autocomplete", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "searchChange": "searchChange"; }, ["optionTpl"], never, true, never>;
+}
+
+declare class CheckboxComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** Text label rendered alongside the checkbox. */
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onChanged(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "fk-checkbox", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DateInputComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly isReadonly: _angular_core.InputSignal<boolean>;
+    /** Earliest selectable date as an ISO 8601 date string (YYYY-MM-DD). */
+    readonly min: _angular_core.InputSignal<string | null>;
+    /** Latest selectable date as an ISO 8601 date string (YYYY-MM-DD). */
+    readonly max: _angular_core.InputSignal<string | null>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get readonly(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private value;
+    private onChange;
+    private onTouched;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateInputComponent, "fk-date-input", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "isReadonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DatetimeInputComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly isReadonly: _angular_core.InputSignal<boolean>;
+    /** Earliest selectable datetime as an ISO 8601 local datetime string. */
+    readonly min: _angular_core.InputSignal<string | null>;
+    /** Latest selectable datetime as an ISO 8601 local datetime string. */
+    readonly max: _angular_core.InputSignal<string | null>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get readonly(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private value;
+    private onChange;
+    private onTouched;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatetimeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatetimeInputComponent, "fk-datetime-input", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "isReadonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Files emitted from `fk-file-dropzone`. Always an array even when
+ * `multiple` is false — consumers in single-file mode just read
+ * `files[0]`. Empty arrays are never emitted (the component swallows
+ * empty drop/change events).
+ */
+type FkFileDropzoneSelection = readonly File[];
+
+/**
+ * A drag-and-drop file input. Pairs a styled, tokenized "drop here or
+ * click to browse" surface with a hidden native file input so the
+ * component remains keyboard-, click-, and drag-accessible without
+ * any consumer wiring.
+ *
+ * Event-out (not CVA-bound) — emits a `File[]` from `(filesSelected)`
+ * for both drop and browse paths. Use `fk-file-upload` instead when
+ * you need a reactive-forms control with `FileList` value semantics.
+ */
+declare class FileDropzoneComponent {
+    /** MIME types or file extensions the native file picker should accept (e.g. "image/*,.pdf"). */
+    readonly accept: _angular_core.InputSignal<string | null>;
+    /** Whether the user can select more than one file at a time. */
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    /** When true, prevents drag-and-drop and click-to-browse interaction. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Icon name rendered inside the dropzone surface. */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Primary prompt text displayed inside the dropzone. */
+    readonly prompt: _angular_core.InputSignal<string>;
+    /** Secondary hint text shown below the prompt. */
+    readonly hint: _angular_core.InputSignal<string | null>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Fires with the selected File array whenever the user drops or browses files. */
+    readonly filesSelected: _angular_core.OutputEmitterRef<FkFileDropzoneSelection>;
+    protected readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onChange(event: Event): void;
+    private emit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileDropzoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileDropzoneComponent, "fk-file-dropzone", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "prompt": { "alias": "prompt"; "required": true; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "filesSelected": "filesSelected"; }, never, never, true, never>;
+}
+
+declare class FileUploadComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when no file has been selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    /** MIME types or file extensions the native file picker should accept. */
+    readonly accept: _angular_core.InputSignal<string | null>;
+    /** Whether the user can select more than one file at a time. */
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly fileNames: _angular_core.WritableSignal<string[]>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    private files;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: FileList | null): void;
+    registerOnChange(fn: (value: FileList | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFileChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploadComponent, "fk-file-upload", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type InputType = 'text' | 'email' | 'tel' | 'url' | 'search';
+
+declare class InputComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** HTML input type attribute (e.g. "text", "email", "search"). */
+    readonly type: _angular_core.InputSignal<InputType>;
+    /** Placeholder text shown when the input has no value. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Native `autocomplete` attribute token (e.g. "username", "email",
+     * "name", "off"). Null omits the attribute entirely. Set this on
+     * identifying fields (login email, name) so browsers and password
+     * managers behave correctly — see fk-password-input for the password
+     * counterpart.
+     */
+    readonly autocomplete: _angular_core.InputSignal<string | null>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly isReadonly: _angular_core.InputSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get readonly(): boolean;
+    constructor();
+    get describedByIds(): string[];
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private value;
+    private onChange;
+    private onTouched;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "fk-input", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "isReadonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NumberInputComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when the input has no value. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly isReadonly: _angular_core.InputSignal<boolean>;
+    /** Minimum allowed numeric value. */
+    readonly min: _angular_core.InputSignal<number | null>;
+    /** Maximum allowed numeric value. */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Increment step for the native number input spinner. */
+    readonly step: _angular_core.InputSignal<number | null>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get readonly(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private value;
+    private onChange;
+    private onTouched;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInputComponent, "fk-number-input", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "isReadonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type PasswordAutoComplete = 'current-password' | 'new-password';
+
+declare class PasswordInputComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when the input has no value. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    /** Autocomplete hint passed to the native input — use "current-password" or "new-password". */
+    readonly autocomplete: _angular_core.InputSignal<PasswordAutoComplete>;
+    /** Whether the show/hide password toggle button is rendered. */
+    readonly showToggle: _angular_core.InputSignal<boolean>;
+    /** Icon size for the visibility toggle button. */
+    readonly toggleIconSize: _angular_core.InputSignal<IconSize>;
+    /** Icon color for the visibility toggle button. */
+    readonly toggleIconColor: _angular_core.InputSignal<IconColor>;
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    readonly toggleSizeStyle: _angular_core.Signal<string>;
+    readonly toggleColorStyle: _angular_core.Signal<string | null>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    /** Toggles the password field between visible plain text and masked mode. */
+    toggleVisibility(): void;
+    private value;
+    private onChange;
+    private onTouched;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasswordInputComponent, "fk-password-input", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "showToggle": { "alias": "showToggle"; "required": false; "isSignal": true; }; "toggleIconSize": { "alias": "toggleIconSize"; "required": false; "isSignal": true; }; "toggleIconColor": { "alias": "toggleIconColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface RadioOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+
+declare class RadioComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly className: _angular_core.InputSignal<string>;
+    /** List of radio options to render. */
+    readonly options: _angular_core.InputSignal<RadioOption[]>;
+    /** HTML name attribute shared across all radio buttons in the group. */
+    readonly name: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    value: string | number;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: string | number): void;
+    registerOnChange(fn: (value: string | number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onSelectionChange(value: string | number): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioComponent, "fk-radio", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ProgressSegment {
+    value: number;
+    color?: string;
+    label?: string;
+}
+type SegmentedBarSize = 'sm' | 'md' | 'lg';
+
+declare class SegmentedBarComponent {
+    /** Segments to render, each with a value, optional label, and color. */
+    readonly segments: _angular_core.InputSignal<ProgressSegment[]>;
+    /** Total maximum value; defaults to the sum of all segment values when null. */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Size variant controlling bar height via design tokens. */
+    readonly size: _angular_core.InputSignal<SegmentedBarSize>;
+    /** CSS color for the unfilled track; defaults to the theme token when null. */
+    readonly trackColor: _angular_core.InputSignal<string | null>;
+    /** Explicit bar height that overrides the size-token value. */
+    readonly height: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedBy: _angular_core.InputSignal<string | null>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly segmentTotal: _angular_core.Signal<number>;
+    readonly effectiveMax: _angular_core.Signal<number>;
+    readonly normalizedSegments: _angular_core.Signal<{
+        percentage: number;
+        value: number;
+        color?: string;
+        label?: string;
+    }[]>;
+    readonly valueText: _angular_core.Signal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostRole(): string;
+    get hostAriaValueMin(): number;
+    get hostAriaValueMax(): number;
+    get hostAriaValueNow(): number;
+    get hostAriaValueText(): string;
+    get hostAriaLabel(): string | null;
+    get hostAriaDescribedBy(): string | null;
+    get hostId(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedBarComponent, "fk-segmented-bar", never, { "segments": { "alias": "segments"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SelectOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+
+declare class SelectComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLSelectElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** List of options to render inside the native select element. */
+    readonly options: _angular_core.InputSignal<SelectOption[]>;
+    /** Placeholder option displayed when no value is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    value: string | number;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: string | number): void;
+    registerOnChange(fn: (value: string | number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onSelectionChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "fk-select", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SliderComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    /** Minimum value of the slider range. */
+    readonly min: _angular_core.InputSignal<number>;
+    /** Maximum value of the slider range. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Increment step between slider positions. */
+    readonly step: _angular_core.InputSignal<number>;
+    /** Whether the current numeric value is displayed alongside the thumb. */
+    readonly showValue: _angular_core.InputSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    currentValue: number;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "fk-slider", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SwitchComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onChanged(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "fk-switch", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TagInputComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** Placeholder text shown in the text input when there are no tags. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    /** Character(s) that commit the current input as a new tag (default: comma). */
+    readonly separator: _angular_core.InputSignal<string>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly tags: _angular_core.WritableSignal<string[]>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    /** Focuses the inner text input element. */
+    focusInput(): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: string[]): void;
+    registerOnChange(fn: (value: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Adds a tag to the list if it is non-empty and not already present. */
+    addTag(tag: string): void;
+    /** Removes the given tag from the list. */
+    removeTag(tag: string, event?: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagInputComponent, "fk-tag-input", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TextareaComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLTextAreaElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when the textarea has no value. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly isReadonly: _angular_core.InputSignal<boolean>;
+    /** Number of visible text rows for the initial textarea height. */
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get readonly(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private value;
+    private onChange;
+    private onTouched;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "fk-textarea", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "isReadonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TimeInputComponent implements ControlValueAccessor, FieldControl {
+    private readonly cdr;
+    readonly ngControl: NgControl | null;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly isRequired: _angular_core.InputSignal<boolean>;
+    readonly isReadonly: _angular_core.InputSignal<boolean>;
+    /** Earliest selectable time as an HH:MM string. */
+    readonly min: _angular_core.InputSignal<string | null>;
+    /** Latest selectable time as an HH:MM string. */
+    readonly max: _angular_core.InputSignal<string | null>;
+    /** Step in seconds between selectable time values. */
+    readonly step: _angular_core.InputSignal<number | null>;
+    readonly id: string;
+    readonly describedByIdsSignal: _angular_core.WritableSignal<string[]>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get focused(): boolean;
+    get empty(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get readonly(): boolean;
+    get describedByIds(): string[];
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    private value;
+    private onChange;
+    private onTouched;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimeInputComponent, "fk-time-input", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "isRequired": { "alias": "required"; "required": false; "isSignal": true; }; "isReadonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AutocompleteComponent, CheckboxComponent, DEFAULT_ERROR_MESSAGES, DateInputComponent, DatetimeInputComponent, ERROR_MESSAGES, ErrorComponent, FIELD_CONTROL, FK_AUTOCOMPLETE_OPTION_TPL, FK_PREFIX, FK_SUFFIX, FORM, FieldArrayOutletComponent, FieldGroupComponent, FieldOutletComponent, FieldRegistry, FileDropzoneComponent, FileUploadComponent, FkAutocompleteOptionTplDirective, FkPrefixDirective, FkSuffixDirective, FormComponent, FormFieldComponent, FormRendererComponent, FormSectionComponent, HintComponent, InputComponent, LabelComponent, NumberInputComponent, PasswordInputComponent, RadioComponent, SchemaParser, SectionOutletComponent, SegmentedBarComponent, SelectComponent, SliderComponent, SwitchComponent, TagInputComponent, TextareaComponent, TimeInputComponent, ValidationRegistry, getError, getFieldState, getInvalidFields, hasError, interpolateMessage, isFormValid, markAllTouched, resolveErrorMessage };
+export type { AsyncValidatorConfig, AsyncValidatorFactory, AutocompleteFilterMode, AutocompleteOption, ErrorMessages, FieldControl, FieldGroupLayout, FieldSchema, FieldState, FieldUiConfig, FkFileDropzoneSelection, FormRendererSubmitValue, FormSchema, FormSchemaSection, FormStatus, InputType, LabelEndLink, LayoutColumn, LayoutRow, Option, PasswordAutoComplete, ProgressSegment, RadioOption, SegmentedBarSize, SelectOption, ShowErrorsOn, ValidatorConfig, ValidatorFactory, VisibilityRule };