ng-hub-ui-forms 21.0.0

package/types/ng-hub-ui-forms.d.ts

@@ -0,0 +1,1463 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterContentInit, OnDestroy, TemplateRef, ElementRef, InjectionToken, EnvironmentProviders, PipeTransform, NgZone } from '@angular/core';
+import { NgControl, ControlContainer, ControlValueAccessor, ValidationErrors, AbstractControl, ValidatorFn } from '@angular/forms';
+import { Subject, OperatorFunction } from 'rxjs';
+import * as ng_hub_ui_forms from 'ng-hub-ui-forms';
+import { SafeUrl } from '@angular/platform-browser';
+
+/**
+ * Base class for every form field in `ng-hub-ui-forms`.
+ *
+ * Provides the shared `ControlValueAccessor`-adjacent plumbing used by the field components:
+ * reactive `required` tracking derived from the bound control's validators, programmatic
+ * show/hide/toggle helpers exposed on the underlying `AbstractControl`, and lifecycle wiring.
+ *
+ * Subclasses must provide the injected `NgControl` and `ControlContainer` instances.
+ */
+declare abstract class HubFormControl implements OnInit, AfterContentInit, OnDestroy {
+    /**
+     * Name of the form control when used within a form group/array.
+     */
+    readonly formControlName: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the control is required. Derived from the bound control's validators when reactive.
+     */
+    readonly required: _angular_core.ModelSignal<boolean | null>;
+    /**
+     * Whether the control is hidden.
+     */
+    hidden: boolean;
+    protected _destroy$: Subject<unknown>;
+    protected _isFormControl: boolean;
+    protected abstract _control: NgControl;
+    protected abstract _controlContainer: ControlContainer;
+    /**
+     * Shows the control.
+     */
+    show: () => void;
+    /**
+     * Hides the control.
+     */
+    hide: () => void;
+    /**
+     * Toggles the control visibility.
+     */
+    toggle: () => void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Attaches `show`, `hide` and `toggle` helpers to the underlying form control object.
+     *
+     * Best-effort: if the control cannot be resolved (e.g. the container is not yet initialized),
+     * the helpers are simply not attached. This never throws — a missing convenience must not break
+     * rendering.
+     */
+    protected setShowAndHideFunctions(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubFormControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubFormControl, never, never, { "formControlName": { "alias": "formControlName"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "required": "requiredChange"; }, never, never, true, never>;
+}
+
+/**
+ * Marks a template as the validation error message for a specific error key.
+ *
+ * Used by form fields and form containers to override the default message rendered
+ * for a given validation error (e.g. `required`, `min`, `equal`).
+ *
+ * @example
+ * ```html
+ * <hub-input formControlName="age">
+ *   <ng-template hubValidationError key="min">Must be at least 18.</ng-template>
+ * </hub-input>
+ * ```
+ */
+declare class HubValidationErrorDirective {
+    /** Unique key for the validation error (e.g. `'required'`, `'min'`). */
+    readonly key: _angular_core.InputSignal<string>;
+    /** Template reference for the error message. */
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubValidationErrorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubValidationErrorDirective, "[hubValidationError]", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Shared base for single-value form fields (input, textarea, slider, select…).
+ *
+ * Extends {@link HubFormControl} with the `ControlValueAccessor` plumbing and the automatic
+ * validation-error display that every field shares:
+ *
+ * - Injects the bound `NgControl` / `ControlContainer` and registers itself as value accessor.
+ * - Exposes `isInvalid` / `errors`, resolving from the reactive control or from native validity.
+ * - Collects projected `hubValidationError` templates and resolves messages through the per-field
+ *   override, the global {@link provideHubForms} config, or the built-in defaults.
+ * - Keeps the (OnPush) view in sync with the control via `control.events` + `markForCheck`.
+ *
+ * Subclasses only implement the value-specific bits: the `_value` signal, `writeValue`, the change
+ * handler and their own template/inputs.
+ */
+declare abstract class HubFieldControl extends HubFormControl implements ControlValueAccessor, AfterContentInit {
+    #private;
+    protected readonly _elementRef: ElementRef<any>;
+    protected readonly _control: NgControl;
+    protected readonly _controlContainer: ControlContainer;
+    /** Resolved templates that override the default message of a given error key. */
+    protected _errorTemplates: {
+        [key: string]: TemplateRef<any>;
+    };
+    /** Stable unique id linking the label and the control. */
+    readonly id: string;
+    /** Query for a projected `hubFormText` helper template. */
+    readonly formTextTmp: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /** Query for projected `hubValidationError` templates. */
+    readonly errorTpts: _angular_core.Signal<readonly HubValidationErrorDirective[]>;
+    /** Whether the field is disabled. */
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    /** Per-field override for the invalid-feedback message builder. */
+    readonly invalidFeedbackTemplateFn: _angular_core.InputSignal<((key: string, value: any) => string) | null>;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    protected readonly _nativeErrors: _angular_core.WritableSignal<ValidationErrors | null>;
+    protected readonly _nativeTouched: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** Whether the field should display its error feedback (touched + invalid). */
+    get isInvalid(): boolean;
+    /** Current validation errors, from the reactive control or from native validity. */
+    get errors(): ValidationErrors | null;
+    ngAfterContentInit(): void;
+    /**
+     * Marks the field as touched when focus leaves it.
+     *
+     * @param event - The originating focus event.
+     */
+    handleBlur(event?: FocusEvent): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Resolves the message for a given validation error, honoring per-field and global overrides.
+     *
+     * @param key - The validation error key.
+     * @param value - The error payload.
+     * @returns The resolved message (HTML allowed).
+     */
+    getInvalidFeedbackTemplate(key: string, value: any): string;
+    abstract writeValue(value: any): void;
+    /**
+     * Derives native validation errors when the field is used without a reactive control.
+     *
+     * @param target - The DOM element to read validity from, if available.
+     */
+    protected updateNativeErrors(target?: EventTarget | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubFieldControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubFieldControl, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidFeedbackTemplateFn": { "alias": "invalidFeedbackTemplateFn"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; }, ["formTextTmp", "errorTpts"], never, true, never>;
+}
+
+/** When a container reveals its group-level validation errors. */
+type HubGroupErrorTrigger = 'touched' | 'submit' | 'always';
+/**
+ * Shared base for form *containers* (`hub-form`, `hub-fieldset`, `hub-legend`).
+ *
+ * Resolves a target `FormGroup`/`FormArray` — provided explicitly via the `group` input or by name
+ * from the parent `ControlContainer` — and automatically surfaces its **group-level** validation
+ * errors (those set on the group itself by cross-field validators such as `hubAreEqual`), the same
+ * way the field components surface control-level errors.
+ *
+ * It intentionally ignores child-control errors: those are rendered by the individual fields.
+ */
+declare abstract class HubGroupControl implements AfterContentInit, OnDestroy {
+    #private;
+    protected readonly _config: ng_hub_ui_forms.HubFormsConfig;
+    private readonly _parent;
+    private readonly _self;
+    protected _destroy$: Subject<void>;
+    /** Explicit target group/array. Takes precedence over name resolution. */
+    readonly group: _angular_core.InputSignal<AbstractControl<any, any, any> | null>;
+    /** Name of the target group/array within the parent container (alternative to `group`). */
+    readonly groupName: _angular_core.InputSignal<string | undefined>;
+    /** When to reveal the group-level errors. `touched` (default) or `always`. */
+    readonly errorTrigger: _angular_core.InputSignal<HubGroupErrorTrigger>;
+    /** Per-container override for the invalid-feedback message builder. */
+    readonly invalidFeedbackTemplateFn: _angular_core.InputSignal<((key: string, value: any) => string) | null>;
+    /** Query for projected `hubValidationError` templates. */
+    readonly errorTpts: _angular_core.Signal<readonly HubValidationErrorDirective[]>;
+    protected _errorTemplates: {
+        [key: string]: TemplateRef<any>;
+    };
+    /**
+     * The currently bound group control. A `computed` (not an `effect`-fed signal) so it resolves
+     * synchronously on first render — otherwise a `<form [formGroup]>` would briefly bind `null` and
+     * the projected `formControlName` fields would fail to locate their controls.
+     */
+    protected readonly _control: _angular_core.Signal<AbstractControl<any, any, any> | null>;
+    /** Whether the owning form has been submitted (set by `hub-form`; drives the `submit` trigger). */
+    protected readonly _submitted: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** Whether the group's own (cross-field) errors should be displayed. */
+    get isInvalid(): boolean;
+    /** The group's own validation errors (excludes child-control errors). */
+    get errors(): ValidationErrors | null;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Resolves the message for a given group-level validation error.
+     *
+     * @param key - The validation error key.
+     * @param value - The error payload.
+     * @returns The resolved message (HTML allowed).
+     */
+    getInvalidFeedbackTemplate(key: string, value: any): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubGroupControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubGroupControl, never, never, { "group": { "alias": "group"; "required": false; "isSignal": true; }; "groupName": { "alias": "groupName"; "required": false; "isSignal": true; }; "errorTrigger": { "alias": "errorTrigger"; "required": false; "isSignal": true; }; "invalidFeedbackTemplateFn": { "alias": "invalidFeedbackTemplateFn"; "required": false; "isSignal": true; }; }, {}, ["errorTpts"], never, true, never>;
+}
+
+/**
+ * Default, human-readable messages for the most common Angular validation errors.
+ *
+ * Consumers can override this per field (via the `invalidFeedbackTemplateFn` input) or globally
+ * (via {@link provideHubForms}). The function receives the error `key` and its `value` (the payload
+ * Angular stores for that error) and returns the message string (HTML allowed).
+ *
+ * @param key - The validation error key (e.g. `required`, `min`, `minlength`, `equal`).
+ * @param value - The error payload as stored on the control's `errors` object.
+ * @returns A localized-by-default English message describing the error.
+ */
+declare function defaultInvalidFeedback(key: string, value: any): string;
+
+/** Selection mode for `<hub-datepicker>`. */
+type HubDatepickerMode = 'single' | 'range';
+/** A selected date range (ISO `YYYY-MM-DD` strings, or `null` while incomplete). */
+interface HubDateRange {
+    start: string | null;
+    end: string | null;
+}
+/** The CVA value of `<hub-datepicker>`: an ISO string in `single` mode, a range in `range` mode. */
+type HubDateValue = string | HubDateRange | null;
+/**
+ * Localizable, overridable labels for the datepicker (button text + accessibility names).
+ * Month and weekday names come from the `Intl` API and need no translation.
+ */
+interface HubDatepickerLabels {
+    /** Aria label for the calendar trigger button. */
+    openCalendar: string;
+    /** Aria label for the previous-month button. */
+    previousMonth: string;
+    /** Aria label for the next-month button. */
+    nextMonth: string;
+    /** Aria label for the previous-year button. */
+    previousYear: string;
+    /** Aria label for the next-year button. */
+    nextYear: string;
+    /** Text + aria label for the "today" shortcut button. */
+    today: string;
+    /** Text + aria label for the "clear" button. */
+    clear: string;
+}
+/** Global datepicker defaults, set via {@link provideHubForms}. */
+interface HubDatepickerConfig {
+    /** First weekday (0 = Sunday, 1 = Monday…). */
+    firstDayOfWeek: number;
+    /** Weekday header width. */
+    weekdayFormat: 'short' | 'narrow' | 'long';
+    /** `Intl` options used to format the displayed value. */
+    displayFormat: Intl.DateTimeFormatOptions;
+    /** Separator between the two dates of a range in the input display. */
+    rangeSeparator: string;
+    /** Localizable labels. */
+    labels: HubDatepickerLabels;
+}
+/** Built-in (English) datepicker labels. */
+declare const defaultHubDatepickerLabels: HubDatepickerLabels;
+/** Built-in datepicker defaults. */
+declare const defaultHubDatepickerConfig: HubDatepickerConfig;
+
+/**
+ * Global configuration contract for `ng-hub-ui-forms`.
+ */
+interface HubFormsConfig {
+    /**
+     * Builds the message shown for a given validation error.
+     *
+     * @param key - The validation error key (e.g. `required`, `min`).
+     * @param value - The error payload stored on the control.
+     * @returns The message string (HTML allowed).
+     */
+    invalidFeedbackTemplateFn: (key: string, value: any) => string;
+    /** Global datepicker defaults (locale labels, formats, first day of week…). */
+    datepicker: HubDatepickerConfig;
+}
+/**
+ * Default configuration used when {@link provideHubForms} is not called.
+ */
+declare const defaultHubFormsConfig: HubFormsConfig;
+/**
+ * Injection token holding the resolved {@link HubFormsConfig}.
+ *
+ * Falls back to {@link defaultHubFormsConfig} when no provider is registered, so the library works
+ * out of the box without bootstrapping.
+ */
+declare const HUB_FORMS_CONFIG: InjectionToken<HubFormsConfig>;
+/**
+ * Registers a global configuration for `ng-hub-ui-forms`.
+ *
+ * @param config - Partial configuration; unspecified fields keep their defaults.
+ * @returns Environment providers to add to `bootstrapApplication` (or a route's providers).
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideHubForms({
+ *       invalidFeedbackTemplateFn: (key) => myI18n.translate(`errors.${key}`)
+ *     })
+ *   ]
+ * });
+ * ```
+ */
+declare function provideHubForms(config?: DeepPartial<HubFormsConfig>): EnvironmentProviders;
+/** Recursively-optional version of a type, for partial config overrides. */
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+
+/**
+ * Possible display types for form helper text.
+ */
+type FormTextType = 'bottom' | 'tooltip';
+/**
+ * Enum for form helper text display types.
+ */
+declare enum FormTextTypes {
+    Bottom = "bottom",
+    Tooltip = "tooltip"
+}
+/**
+ * Possible label display types shared by the form field components.
+ */
+type HubLabelType = 'floating' | 'stacked' | 'horizontal';
+/**
+ * Enum for label display types.
+ */
+declare enum HubLabelTypes {
+    Floating = "floating",
+    Stacked = "stacked",
+    Horizontal = "horizontal"
+}
+
+/**
+ * Supported formats (native input types) for the `<hub-input>` component.
+ */
+type HubInputFormat = 'text' | 'number' | 'password' | 'email' | 'tel' | 'url' | 'color' | 'checkbox' | 'switch' | 'counter' | 'file';
+/**
+ * Enum mirror of {@link HubInputFormat} for ergonomic template usage.
+ */
+declare enum HubInputFormats {
+    Text = "text",
+    Number = "number",
+    Password = "password",
+    Email = "email",
+    Tel = "tel",
+    Url = "url",
+    Color = "color",
+    Checkbox = "checkbox",
+    Switch = "switch",
+    Counter = "counter",
+    File = "file"
+}
+
+/** Value held by a `<hub-input>` across its supported formats. */
+type HubInputValue = number | string | boolean | File | FileList | null;
+/**
+ * Accessible form field with automatic validation-error display.
+ *
+ * Works both with Reactive Forms (`formControlName` / `[formControl]`) and as a standalone
+ * value-bound control. When invalid and touched, it renders the control's errors using the
+ * default messages, the global {@link provideHubForms} config, the per-field
+ * `invalidFeedbackTemplateFn` input, or projected `hubValidationError` templates.
+ *
+ * Formats: `text`, `number`, `password`, `email`, `tel`, `url`, `color`, `checkbox`, `switch`,
+ * `counter`. Label types: `stacked`, `floating`, `horizontal`. Text-like formats support prepend /
+ * append addons (input groups). Numeric formats auto-attach `min`/`max` validators when bound to a
+ * reactive control.
+ *
+ * @example
+ * ```html
+ * <hub-input formControlName="email" type="email" label="Email" />
+ * <hub-input formControlName="accept" type="switch" label="Accept terms" />
+ * <hub-input formControlName="qty" type="counter" label="Quantity" [min]="1" [max]="9" />
+ * ```
+ */
+declare class HubInputComponent extends HubFieldControl {
+    #private;
+    protected readonly _inputFormats: typeof HubInputFormats;
+    protected readonly _labelTypes: typeof HubLabelTypes;
+    protected readonly _formTextTypes: typeof FormTextTypes;
+    protected readonly _value: _angular_core.WritableSignal<HubInputValue>;
+    /** Whether the password value is currently revealed (password format only). */
+    showPassword: boolean;
+    /** Native input type. */
+    readonly type: _angular_core.InputSignal<HubInputFormat>;
+    /** Label text. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Label display type (`stacked`, `floating`, `horizontal`). */
+    readonly labelType: _angular_core.ModelSignal<HubLabelType>;
+    /** Placeholder text. */
+    readonly placeholder: _angular_core.ModelSignal<string>;
+    /** Minimum value (numeric / counter inputs). */
+    readonly min: _angular_core.ModelSignal<number | undefined>;
+    /** Maximum value (numeric / counter inputs). */
+    readonly max: _angular_core.ModelSignal<number | undefined>;
+    /** Step value (numeric / counter inputs). */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Whether the input is read-only. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Helper text shown below the control. */
+    readonly formText: _angular_core.InputSignal<string>;
+    /** Helper text placement. Only `bottom` is supported. */
+    readonly formTextType: _angular_core.InputSignal<FormTextType>;
+    /** Text shown before the control as an input-group addon (text-like formats). */
+    readonly prepend: _angular_core.InputSignal<string | string[]>;
+    /** Text shown after the control as an input-group addon (text-like formats). */
+    readonly append: _angular_core.InputSignal<string | string[]>;
+    /** Extra CSS classes applied to the host element. */
+    readonly classlist: _angular_core.InputSignal<string>;
+    /**
+     * Pattern mask for text-like formats. Tokens: `0` = digit, `A` = letter, `*` =
+     * alphanumeric; any other character is an auto-inserted literal separator.
+     * Example: `0000 0000 0000 0000` (card), `00/00/0000` (date).
+     */
+    readonly mask: _angular_core.InputSignal<string>;
+    /**
+     * When a `mask` is set, controls the form value: `false` (default) stores the
+     * formatted text (e.g. `1234 5678`); `true` stores only the typed characters
+     * (e.g. `12345678`).
+     */
+    readonly unmaskValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emits whenever the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<HubInputValue>;
+    /** Emits the current value when Enter is pressed. */
+    readonly enter: _angular_core.OutputEmitterRef<HubInputValue>;
+    /** Accepted file types (file format), e.g. `image/*,.pdf`. */
+    readonly accept: _angular_core.InputSignal<string>;
+    /** Whether multiple files can be selected (file format). */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Text of the file-picker button (file format). */
+    readonly buttonLabel: _angular_core.InputSignal<string>;
+    /** Reference to the hidden native file input. */
+    protected readonly fileInput: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    /** Whether the current format renders a checkable control (checkbox / switch). */
+    protected readonly isCheckable: _angular_core.Signal<boolean>;
+    /** Display label for the selected file(s). */
+    protected readonly fileLabel: _angular_core.Signal<string>;
+    /** Normalized list of prepend addons. */
+    protected readonly _prepend: _angular_core.Signal<string[]>;
+    /** Normalized list of append addons. */
+    protected readonly _append: _angular_core.Signal<string[]>;
+    /** Whether the control is wrapped in an input group (has addons). */
+    protected readonly hasGroup: _angular_core.Signal<boolean>;
+    /** Resolves the actual native `type` attribute, accounting for password reveal. */
+    protected readonly resolvedType: _angular_core.Signal<string>;
+    ngAfterContentInit(): void;
+    writeValue(value: HubInputValue): void;
+    /**
+     * Reads the new value from an input/model event and propagates it to the form and outputs.
+     *
+     * @param event - A DOM event or the raw value emitted by `ngModelChange`.
+     */
+    setValue(event: any): void;
+    /** Increments the counter value, clamped to `max`. */
+    protected add(): void;
+    /** Decrements the counter value, clamped to `min`. */
+    protected subtract(): void;
+    /** Toggles password visibility. */
+    protected togglePassword(): void;
+    /** Opens the native file dialog. */
+    protected triggerFile(): void;
+    /**
+     * Reads the selected file(s) from the native input and propagates them.
+     *
+     * @param event - The native `change` event of the file input.
+     */
+    protected setFileValue(event: Event): void;
+    /** Clears the selected file(s). */
+    protected clearFile(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubInputComponent, "hub-input", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelType": { "alias": "labelType"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "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; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "formText": { "alias": "formText"; "required": false; "isSignal": true; }; "formTextType": { "alias": "formTextType"; "required": false; "isSignal": true; }; "prepend": { "alias": "prepend"; "required": false; "isSignal": true; }; "append": { "alias": "append"; "required": false; "isSignal": true; }; "classlist": { "alias": "classlist"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "unmaskValue": { "alias": "unmaskValue"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; }, { "labelType": "labelTypeChange"; "placeholder": "placeholderChange"; "min": "minChange"; "max": "maxChange"; "valueChange": "valueChange"; "enter": "enter"; }, never, never, true, never>;
+}
+
+/** Character set accepted by the OTP field. */
+type HubOtpMode = 'numeric' | 'alphanumeric' | 'alpha';
+/**
+ * Segmented one-time-code input (`hub-otp-input`): a row of single-character cells for
+ * entering verification / 2FA codes. Supports auto-advance, backspace navigation, arrow
+ * keys, and pasting the whole code at once. Implements `ControlValueAccessor`, so the
+ * form value is the concatenated string.
+ *
+ * ```html
+ * <hub-otp-input formControlName="code" [length]="6" label="Verification code" />
+ * <hub-otp-input formControlName="pin" [length]="4" mode="numeric" [secret]="true" />
+ * ```
+ */
+declare class HubOtpInputComponent extends HubFieldControl {
+    #private;
+    protected readonly _labelTypes: typeof HubLabelTypes;
+    protected readonly _formTextTypes: typeof FormTextTypes;
+    /** Number of cells / characters in the code. */
+    readonly length: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Accepted character set. */
+    readonly mode: _angular_core.InputSignal<HubOtpMode>;
+    /** Field label. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Label placement. */
+    readonly labelType: _angular_core.InputSignal<HubLabelType>;
+    /** Helper text shown below the cells. */
+    readonly formText: _angular_core.InputSignal<string>;
+    /** Helper-text placement. */
+    readonly formTextType: _angular_core.InputSignal<FormTextType>;
+    /** Masks the characters like a password. */
+    readonly secret: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Renders the cells read-only. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Inserts a visual separator every N cells (0 = none). */
+    readonly separatorEvery: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The separator character shown between groups. */
+    readonly separator: _angular_core.InputSignal<string>;
+    /** Extra CSS classes applied to the host element. */
+    readonly classlist: _angular_core.InputSignal<string>;
+    /** Emits whenever the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Emits the full code once every cell is filled. */
+    readonly completed: _angular_core.OutputEmitterRef<string>;
+    /** References to the cell inputs, for focus management. */
+    private readonly _cells;
+    /** Index list driving the `@for`. */
+    readonly cells: _angular_core.Signal<number[]>;
+    /** Per-cell characters derived from the current value. */
+    readonly chars: _angular_core.Signal<string[]>;
+    /** ARIA label prefix for each cell. */
+    readonly ariaCellLabel: _angular_core.Signal<string>;
+    writeValue(value: unknown): void;
+    /** Handles typing into a cell: keep the last valid char, advance focus, and emit. */
+    protected onInput(index: number, event: Event): void;
+    /** Handles navigation / deletion keys. */
+    protected onKeydown(index: number, event: KeyboardEvent): void;
+    /** Distributes a pasted code across the cells starting at the current one. */
+    protected onPaste(index: number, event: ClipboardEvent): void;
+    /** Selects the cell content on focus for quick overwrite. */
+    protected select(index: number): void;
+    /** Marks the field as touched when focus leaves the whole group. */
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubOtpInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubOtpInputComponent, "hub-otp-input", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelType": { "alias": "labelType"; "required": false; "isSignal": true; }; "formText": { "alias": "formText"; "required": false; "isSignal": true; }; "formTextType": { "alias": "formTextType"; "required": false; "isSignal": true; }; "secret": { "alias": "secret"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "separatorEvery": { "alias": "separatorEvery"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "classlist": { "alias": "classlist"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "completed": "completed"; }, never, never, true, never>;
+}
+
+/**
+ * Accessible multi-line text field with optional auto-resize, character counter and automatic
+ * validation-error display.
+ *
+ * Shares all the form plumbing (CVA, error feedback, touched tracking) with the other
+ * `ng-hub-ui-forms` fields through {@link HubFieldControl}.
+ *
+ * @example
+ * ```html
+ * <hub-textarea formControlName="bio" label="Biography" [rows]="4" [maxlength]="280" [counter]="true" />
+ * ```
+ */
+declare class HubTextareaComponent extends HubFieldControl {
+    protected readonly _labelTypes: typeof HubLabelTypes;
+    protected readonly _formTextTypes: typeof FormTextTypes;
+    protected readonly _value: _angular_core.WritableSignal<string>;
+    /** Label text. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Label display type (`stacked`, `horizontal`). */
+    readonly labelType: _angular_core.InputSignal<HubLabelType>;
+    /** Placeholder text. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Number of visible text rows. */
+    readonly rows: _angular_core.InputSignalWithTransform<number | undefined, string | number>;
+    /** Number of visible columns. When set, the textarea stops stretching to full width. */
+    readonly cols: _angular_core.InputSignalWithTransform<number | undefined, string | number>;
+    /** Maximum number of characters. Drives both the native limit and the counter. */
+    readonly maxlength: _angular_core.InputSignalWithTransform<number | undefined, string | number>;
+    /** Whether the textarea grows to fit its content. */
+    readonly autoresize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show a character counter below the control. */
+    readonly counter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the textarea is read-only. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Helper text shown below the control. */
+    readonly formText: _angular_core.InputSignal<string>;
+    /** Helper text placement. Only `bottom` is supported in the MVP. */
+    readonly formTextType: _angular_core.InputSignal<FormTextType>;
+    /** Extra CSS classes applied to the host element. */
+    readonly classlist: _angular_core.InputSignal<string>;
+    /** Emits whenever the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Current character counter text (e.g. `12 / 280`). */
+    protected readonly counterText: _angular_core.Signal<string>;
+    writeValue(value: string | null): void;
+    /**
+     * Updates the value from the textarea and propagates it to the form and outputs.
+     *
+     * @param value - The new textarea value.
+     */
+    setValue(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubTextareaComponent, "hub-textarea", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelType": { "alias": "labelType"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "autoresize": { "alias": "autoresize"; "required": false; "isSignal": true; }; "counter": { "alias": "counter"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "formText": { "alias": "formText"; "required": false; "isSignal": true; }; "formTextType": { "alias": "formTextType"; "required": false; "isSignal": true; }; "classlist": { "alias": "classlist"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/** Value of `<hub-slider>`: a number in single mode, a `[lower, upper]` tuple in range mode. */
+type HubSliderValue = number | [number, number];
+/**
+ * Accessible numeric slider with an optional value bubble. Supports a single thumb or a
+ * **dual-thumb range** (`range`), whose value is a `[lower, upper]` tuple.
+ *
+ * Shares the form plumbing (CVA, error feedback, touched tracking) with the other
+ * `ng-hub-ui-forms` fields through {@link HubFieldControl}. The filled track and bubbles are
+ * positioned from the `--hub-slider-from` / `--hub-slider-to` percentages.
+ *
+ * @example
+ * ```html
+ * <hub-slider formControlName="volume" label="Volume" [min]="0" [max]="100" [step]="5" />
+ * <hub-slider formControlName="price" label="Price" [range]="true" [min]="0" [max]="1000" />
+ * ```
+ */
+declare class HubSliderComponent extends HubFieldControl {
+    #private;
+    protected readonly _labelTypes: typeof HubLabelTypes;
+    protected readonly _formTextTypes: typeof FormTextTypes;
+    protected readonly _value: _angular_core.WritableSignal<HubSliderValue>;
+    /** Label text. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Label display type (`stacked`, `horizontal`). */
+    readonly labelType: _angular_core.InputSignal<HubLabelType>;
+    /** Whether the slider selects a `[lower, upper]` range with two thumbs. */
+    readonly range: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Minimum value. */
+    readonly min: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Maximum value. */
+    readonly max: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Step increment. */
+    readonly step: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Whether to show the value bubble(s) above the thumb(s). */
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Helper text shown below the control. */
+    readonly formText: _angular_core.InputSignal<string>;
+    /** Helper text placement. Only `bottom` is supported. */
+    readonly formTextType: _angular_core.InputSignal<FormTextType>;
+    /** Extra CSS classes applied to the host element. */
+    readonly classlist: _angular_core.InputSignal<string>;
+    /** Emits whenever the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<HubSliderValue>;
+    /** Current single value (single mode). */
+    protected readonly single: _angular_core.Signal<number>;
+    /** Lower bound of the current range (range mode). */
+    protected readonly lower: _angular_core.Signal<number>;
+    /** Upper bound of the current range (range mode). */
+    protected readonly upper: _angular_core.Signal<number>;
+    /** Single-thumb position as a clamped 0–100 percentage. */
+    protected readonly percent: _angular_core.Signal<number>;
+    /** Lower-thumb position as a clamped 0–100 percentage. */
+    protected readonly lowerPercent: _angular_core.Signal<number>;
+    /** Upper-thumb position as a clamped 0–100 percentage. */
+    protected readonly upperPercent: _angular_core.Signal<number>;
+    writeValue(value: HubSliderValue | null): void;
+    /**
+     * Updates the single value and propagates it.
+     *
+     * @param value - The new value (string from the DOM or number).
+     */
+    setValue(value: string | number): void;
+    /**
+     * Updates the lower thumb (clamped not to cross the upper thumb).
+     *
+     * @param value - The new lower value.
+     */
+    setLower(value: string | number): void;
+    /**
+     * Updates the upper thumb (clamped not to cross the lower thumb).
+     *
+     * @param value - The new upper value.
+     */
+    setUpper(value: string | number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubSliderComponent, "hub-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelType": { "alias": "labelType"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "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; }; "formText": { "alias": "formText"; "required": false; "isSignal": true; }; "formTextType": { "alias": "formTextType"; "required": false; "isSignal": true; }; "classlist": { "alias": "classlist"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Groups related fields under a `<fieldset>`/`<legend>` and **automatically displays the
+ * group-level (cross-field) validation errors** of the bound `FormGroup`/`FormArray`.
+ *
+ * Bind the target group explicitly with `[group]` (recommended) or by `groupName` resolved from the
+ * parent container. Errors set on the group itself — e.g. by `hubAreEqual` — are rendered without
+ * any extra wiring, mirroring how the field components show control-level errors.
+ *
+ * @example
+ * ```html
+ * <hub-fieldset legend="Credentials" [group]="form.controls.credentials">
+ *   <hub-input formControlName="password" type="password" label="Password" />
+ *   <hub-input formControlName="confirm" type="password" label="Confirm" />
+ * </hub-fieldset>
+ * ```
+ */
+declare class HubFieldsetComponent extends HubGroupControl {
+    /** Legend text. Ignored when a `hubLegend` template is projected. */
+    readonly legend: _angular_core.InputSignal<string>;
+    /** Extra CSS classes applied to the host element. */
+    readonly classlist: _angular_core.InputSignal<string>;
+    /** Query for a projected `hubLegend` template. */
+    readonly legendTmp: _angular_core.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubFieldsetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubFieldsetComponent, "hub-fieldset", never, { "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "classlist": { "alias": "classlist"; "required": false; "isSignal": true; }; }, {}, ["legendTmp"], ["*"], true, never>;
+}
+
+/**
+ * Applied to a reactive `<form [formGroup]>`, **automatically displays the form-level validation
+ * errors** (cross-field errors set on the root group) and centralizes submit handling.
+ *
+ * Because it sits on the same host as the `formGroup` directive, projected `formControlName` fields
+ * resolve their control normally — no extra wiring. On submit it prevents the default navigation,
+ * marks the whole tree as touched (so every field reveals its errors) and reveals the form-level
+ * errors. Bind the form's own `(submit)` event for your handler — there is no custom output, which
+ * keeps the API idiomatic and avoids the double-emit you get when a directive output shadows the
+ * native `submit` event on a `<form>`.
+ *
+ * @example
+ * ```html
+ * <form [formGroup]="form" hubForm (submit)="save()">
+ *   <hub-input formControlName="email" type="email" label="Email" />
+ *   <button type="submit">Save</button>
+ * </form>
+ * ```
+ */
+declare class HubFormComponent extends HubGroupControl {
+    /**
+     * Augments the native form submit: prevents the default navigation, marks the tree as touched
+     * and flips the submitted state so form-level errors appear. The consumer's own `(submit)`
+     * binding still fires for their handler.
+     *
+     * @param event - The native submit event.
+     */
+    protected handleSubmit(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubFormComponent, "form[hubForm]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Presentational legend for a `<hub-fieldset>` (or any grouped section), with optional
+ * required/invalid state styling.
+ *
+ * Use it inside a `hubLegend` template, or standalone as a section title.
+ *
+ * @example
+ * ```html
+ * <hub-fieldset [group]="form.controls.address">
+ *   <ng-template hubLegend>
+ *     <hub-legend [required]="true" [invalid]="form.controls.address.invalid">Shipping address</hub-legend>
+ *   </ng-template>
+ * </hub-fieldset>
+ * ```
+ */
+declare class HubLegendComponent {
+    /** Whether to render the required indicator. */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to render the invalid state styling. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubLegendComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubLegendComponent, "hub-legend", never, { "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Rendering formats for `<hub-select>`.
+ *
+ * - `dropdown` — the ng-select engine (search, virtual scroll, tags…).
+ * - `buttons` — a toggle-button group (single or multiple, per `multiple`).
+ * - `checkbox` — a list of checkboxes (always multiple).
+ * - `radio` — a list of radios (always single).
+ */
+type HubSelectFormat = 'dropdown' | 'buttons' | 'checkbox' | 'radio';
+/**
+ * Enum mirror of {@link HubSelectFormat} for ergonomic template usage.
+ */
+declare enum HubSelectFormats {
+    Dropdown = "dropdown",
+    Buttons = "buttons",
+    Checkbox = "checkbox",
+    Radio = "radio"
+}
+
+/**
+ * Accessible select / multiselect / autocomplete built on the vendored ng-select engine, with the
+ * `ng-hub-ui-forms` conventions on top: CVA binding, automatic error display (via
+ * {@link HubFieldControl}), label, helper text and `--hub-select-*` token theming.
+ *
+ * The underlying ng-select DOM is themed in place from this component's stylesheet
+ * (`ViewEncapsulation.None`) using hub tokens — no external `::ng-deep` overrides, and the vendored
+ * source stays untouched so the upstream sync remains automatic.
+ *
+ * @example
+ * ```html
+ * <hub-select formControlName="country" label="Country" [items]="countries" bindLabel="name" bindValue="code" />
+ * ```
+ */
+declare class HubSelectComponent extends HubFieldControl {
+    protected readonly _labelTypes: typeof HubLabelTypes;
+    protected readonly _formTextTypes: typeof FormTextTypes;
+    protected readonly _selectFormats: typeof HubSelectFormats;
+    protected readonly _value: _angular_core.WritableSignal<any>;
+    protected readonly _optionTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly _optgroupTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly _labelTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly _multiLabelTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly _headerTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly _footerTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly _notFoundTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /** Rendering format (`dropdown`, `buttons`, `checkbox`, `radio`). */
+    readonly format: _angular_core.InputSignal<HubSelectFormat>;
+    /** Lay out the `buttons`/`checkbox`/`radio` options vertically. */
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Items to choose from. */
+    readonly items: _angular_core.InputSignal<any[]>;
+    /** Property used as the visible label for object items. */
+    readonly bindLabel: _angular_core.InputSignal<string | undefined>;
+    /** Property used as the bound value for object items. */
+    readonly bindValue: _angular_core.InputSignal<string | undefined>;
+    /** Property (or fn) used to group items. */
+    readonly groupBy: _angular_core.InputSignal<string | undefined>;
+    /** Label text. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Label display type (`stacked`, `horizontal`). */
+    readonly labelType: _angular_core.InputSignal<HubLabelType>;
+    /** Placeholder text. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Whether multiple selection is allowed. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the options can be searched. */
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the selection can be cleared. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the dropdown closes after a selection. */
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Keep the placeholder visible even when a value is selected. Defaults to `false` (the
+     * placeholder hides on selection) — ng-select v23 defaults this to `true`, which is not the
+     * conventional behavior.
+     */
+    readonly fixedPlaceholder: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the control shows a loading state. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the control is read-only. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Text shown when no items match. */
+    readonly notFoundText: _angular_core.InputSignal<string>;
+    /**
+     * Where the dropdown panel is rendered, as a CSS selector. Defaults to
+     * `'body'` so the panel escapes `overflow`/`transform` ancestors (cards,
+     * scroll containers, modals) and is never clipped. Pass `undefined` to
+     * render it inline within the component instead.
+     */
+    readonly appendTo: _angular_core.InputSignal<string | undefined>;
+    /** Helper text shown below the control. */
+    readonly formText: _angular_core.InputSignal<string>;
+    /** Helper text placement. Only `bottom` is supported. */
+    readonly formTextType: _angular_core.InputSignal<FormTextType>;
+    /** Extra CSS classes applied to the host element. */
+    readonly classlist: _angular_core.InputSignal<string>;
+    /** Emits whenever the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<any>;
+    /** Emits when the control gains focus (dropdown format). */
+    readonly onFocus: _angular_core.OutputEmitterRef<any>;
+    /** Emits when the control loses focus (dropdown format). */
+    readonly onBlur: _angular_core.OutputEmitterRef<any>;
+    /** Emits when the dropdown opens. */
+    readonly onOpen: _angular_core.OutputEmitterRef<void>;
+    /** Emits when the dropdown closes. */
+    readonly onClose: _angular_core.OutputEmitterRef<void>;
+    /** Emits when the value is cleared. */
+    readonly onClear: _angular_core.OutputEmitterRef<void>;
+    /** Emits on search-term changes (use with `typeahead`/async data). */
+    readonly onSearch: _angular_core.OutputEmitterRef<{
+        term: string;
+        items: any[];
+    }>;
+    /** Emits when an item is added to the selection. */
+    readonly onAdd: _angular_core.OutputEmitterRef<any>;
+    /** Emits when an item is removed from the selection. */
+    readonly onRemove: _angular_core.OutputEmitterRef<any>;
+    /** Emits while the dropdown list scrolls (virtual scroll window). */
+    readonly scroll: _angular_core.OutputEmitterRef<{
+        start: number;
+        end: number;
+    }>;
+    /** Emits when the dropdown list is scrolled to the end (infinite loading). */
+    readonly scrollToEnd: _angular_core.OutputEmitterRef<any>;
+    /** Whether the current format selects multiple values. */
+    protected readonly isMulti: _angular_core.Signal<boolean>;
+    writeValue(value: any): void;
+    /**
+     * Propagates the value to the form and outputs.
+     *
+     * @param value - The new value emitted by the control.
+     */
+    setValue(value: any): void;
+    /**
+     * Resolves the visible label of an item, honoring `bindLabel`.
+     *
+     * @param item - The source item.
+     * @returns The label to display.
+     */
+    protected itemLabel(item: any): any;
+    /**
+     * Resolves the bound value of an item, honoring `bindValue`.
+     *
+     * @param item - The source item.
+     * @returns The value stored when the item is selected.
+     */
+    protected itemValue(item: any): any;
+    /**
+     * Whether an item is currently selected (used by the buttons/checkbox/radio formats).
+     *
+     * @param item - The source item.
+     * @returns `true` when the item's value is part of the current selection.
+     */
+    protected isSelected(item: any): boolean;
+    /**
+     * Toggles an item's selection for the buttons/checkbox/radio formats.
+     *
+     * @param item - The item to toggle.
+     */
+    protected toggleItem(item: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubSelectComponent, "hub-select", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "bindLabel": { "alias": "bindLabel"; "required": false; "isSignal": true; }; "bindValue": { "alias": "bindValue"; "required": false; "isSignal": true; }; "groupBy": { "alias": "groupBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelType": { "alias": "labelType"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "fixedPlaceholder": { "alias": "fixedPlaceholder"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "notFoundText": { "alias": "notFoundText"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "formText": { "alias": "formText"; "required": false; "isSignal": true; }; "formTextType": { "alias": "formTextType"; "required": false; "isSignal": true; }; "classlist": { "alias": "classlist"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "onFocus": "onFocus"; "onBlur": "onBlur"; "onOpen": "onOpen"; "onClose": "onClose"; "onClear": "onClear"; "onSearch": "onSearch"; "onAdd": "onAdd"; "onRemove": "onRemove"; "scroll": "scroll"; "scrollToEnd": "scrollToEnd"; }, ["_optionTpl", "_optgroupTpl", "_labelTpl", "_multiLabelTpl", "_headerTpl", "_footerTpl", "_notFoundTpl"], ["*"], true, never>;
+}
+
+/** A calendar cell enriched with its selection / range / disabled / focus state. */
+interface DatepickerCell {
+    date: Date;
+    day: number;
+    currentMonth: boolean;
+    today: boolean;
+    disabled: boolean;
+    selected: boolean;
+    rangeStart: boolean;
+    rangeEnd: boolean;
+    inRange: boolean;
+    focused: boolean;
+}
+/**
+ * Accessible, fully customizable date / range picker built from scratch on native `Date` + CDK
+ * Overlay (no date dependency). Shares the `ng-hub-ui-forms` conventions (CVA, auto error display,
+ * label, helper text, `--hub-datepicker-*` theming) and adds:
+ *
+ * - `single` and `range` selection (`mode`).
+ * - `min` / `max` bounds and a `disabledDates` predicate.
+ * - Keyboard navigation (arrows, Home/End, PageUp/Down, Enter, Escape).
+ * - `Today` and `Clear` shortcuts.
+ * - Full i18n: locale-driven month/weekday names plus overridable `labels`, `displayFormat`,
+ *   `weekdayFormat`, `firstDayOfWeek` and `rangeSeparator` — per instance or globally via
+ *   {@link provideHubForms}.
+ *
+ * The value is an ISO `YYYY-MM-DD` string (`single`) or a `{ start, end }` range (`range`).
+ *
+ * @example
+ * ```html
+ * <hub-datepicker formControlName="stay" mode="range" label="Stay" [min]="today" />
+ * ```
+ */
+declare class HubDatepickerComponent extends HubFieldControl {
+    #private;
+    protected readonly _labelTypes: typeof HubLabelTypes;
+    protected readonly _formTextTypes: typeof FormTextTypes;
+    protected readonly _value: _angular_core.WritableSignal<HubDateValue>;
+    /** Month currently shown in the calendar panel. */
+    protected readonly _viewDate: _angular_core.WritableSignal<Date>;
+    /** Date that currently holds keyboard focus inside the grid. */
+    protected readonly _focusedDate: _angular_core.WritableSignal<Date>;
+    /** Whether the calendar overlay is open. */
+    protected readonly _open: _angular_core.WritableSignal<boolean>;
+    /** Selection mode (`single` or `range`). */
+    readonly mode: _angular_core.InputSignal<HubDatepickerMode>;
+    /** Label text. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Label display type (`stacked`, `horizontal`). */
+    readonly labelType: _angular_core.InputSignal<HubLabelType>;
+    /** Placeholder shown when nothing is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** BCP-47 locale for the display value and month/weekday names. */
+    readonly locale: _angular_core.InputSignal<string>;
+    /** First weekday (0 = Sunday, 1 = Monday…). Falls back to the global config. */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Weekday header width. Falls back to the global config. */
+    readonly weekdayFormat: _angular_core.InputSignal<"short" | "narrow" | "long" | undefined>;
+    /** `Intl` options to format the displayed value. Falls back to the global config. */
+    readonly displayFormat: _angular_core.InputSignal<Intl.DateTimeFormatOptions | undefined>;
+    /** Separator between the two dates of a range. Falls back to the global config. */
+    readonly rangeSeparator: _angular_core.InputSignal<string | undefined>;
+    /** Earliest selectable date (ISO string or `Date`). */
+    readonly min: _angular_core.InputSignal<string | Date | null>;
+    /** Latest selectable date (ISO string or `Date`). */
+    readonly max: _angular_core.InputSignal<string | Date | null>;
+    /** Predicate marking individual dates as non-selectable. */
+    readonly disabledDates: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** Whether to show the clear shortcut. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show the "today" shortcut. */
+    readonly showToday: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether selecting a date closes the calendar (`single` mode only). */
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Per-instance label overrides (merged over the global config). */
+    readonly labels: _angular_core.InputSignal<Partial<HubDatepickerLabels>>;
+    /** Whether the picker is read-only. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Helper text shown below the control. */
+    readonly formText: _angular_core.InputSignal<string>;
+    /** Helper text placement. Only `bottom` is supported. */
+    readonly formTextType: _angular_core.InputSignal<FormTextType>;
+    /** Extra CSS classes applied to the host element. */
+    readonly classlist: _angular_core.InputSignal<string>;
+    /** Emits whenever the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<HubDateValue>;
+    /** Emits when the calendar opens. */
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    /** Emits when the calendar closes. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** Emits the first day of the displayed month when navigating. */
+    readonly viewChange: _angular_core.OutputEmitterRef<Date>;
+    /** Emits when the value is cleared. */
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    protected readonly _labels: _angular_core.Signal<HubDatepickerLabels>;
+    protected readonly _firstDayOfWeek: _angular_core.Signal<number>;
+    protected readonly _weekdayFormat: _angular_core.Signal<"short" | "narrow" | "long">;
+    protected readonly _displayFormat: _angular_core.Signal<Intl.DateTimeFormatOptions>;
+    protected readonly _rangeSeparator: _angular_core.Signal<string>;
+    protected readonly _minDate: _angular_core.Signal<Date | null>;
+    protected readonly _maxDate: _angular_core.Signal<Date | null>;
+    protected readonly rangeStart: _angular_core.Signal<Date | null>;
+    protected readonly rangeEnd: _angular_core.Signal<Date | null>;
+    /** Locale-formatted display string for the input. */
+    protected readonly displayValue: _angular_core.Signal<string>;
+    protected readonly weekdays: _angular_core.Signal<string[]>;
+    protected readonly monthYearLabel: _angular_core.Signal<string>;
+    /** Enriched 6×7 grid for the displayed month. */
+    protected readonly grid: _angular_core.Signal<DatepickerCell[]>;
+    writeValue(value: HubDateValue | Date): void;
+    /** Opens the calendar (no-op when disabled/read-only). */
+    protected open(): void;
+    /** Closes the calendar and marks the control as touched. */
+    protected close(): void;
+    /** Toggles the calendar. */
+    protected toggleCalendar(): void;
+    /** Shifts the displayed month by `delta` and emits {@link viewChange}. */
+    protected shiftMonth(delta: number): void;
+    /** Jumps the view to today (and focuses it). */
+    protected goToToday(): void;
+    /** Clears the value. */
+    protected clear(): void;
+    /**
+     * Selects a day cell. In `single` mode it sets the value; in `range` mode it sets the start
+     * (resetting the range) or completes it, keeping start ≤ end.
+     *
+     * @param cell - The picked cell.
+     */
+    protected selectDay(cell: DatepickerCell): void;
+    /**
+     * Keyboard navigation within the grid.
+     *
+     * @param event - The originating keyboard event (handled on the grid container).
+     */
+    protected onGridKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubDatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubDatepickerComponent, "hub-datepicker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelType": { "alias": "labelType"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "weekdayFormat": { "alias": "weekdayFormat"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "rangeSeparator": { "alias": "rangeSeparator"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "showToday": { "alias": "showToday"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "formText": { "alias": "formText"; "required": false; "isSignal": true; }; "formTextType": { "alias": "formTextType"; "required": false; "isSignal": true; }; "classlist": { "alias": "classlist"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "opened": "opened"; "closed": "closed"; "viewChange": "viewChange"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+declare class NgOptionComponent implements OnInit {
+    readonly value: _angular_core.InputSignal<any>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly elementRef: ElementRef<any>;
+    readonly label: _angular_core.WritableSignal<string>;
+    /** True when this component's inputs are initialized (after first change detection). */
+    readonly isInitialized: _angular_core.WritableSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgOptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgOptionComponent, "ng-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NgSelectConfig {
+    placeholder: string;
+    fixedPlaceholder: boolean;
+    notFoundText: string;
+    typeToSearchText: string;
+    addTagText: string;
+    loadingText: string;
+    clearAllText: string;
+    ariaLabelDropdown: string;
+    disableVirtualScroll: boolean;
+    openOnEnter: boolean;
+    appendTo: string;
+    bindValue: string;
+    bindLabel: string;
+    appearance: string;
+    clearSearchOnAdd: boolean;
+    deselectOnClick: boolean;
+    tabFocusOnClear: boolean;
+    /**
+     * Controls which DOM event is used to detect outside clicks for closing the dropdown.
+     * Defaults to 'click'. Set to 'mousedown' to handle early outside interactions
+     * (useful when backdrops load on click and would otherwise close the dropdown).
+     */
+    outsideClickEvent: 'click' | 'mousedown';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgSelectConfig, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgSelectConfig>;
+}
+
+declare class NgOptionTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgOptionTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgOptionTemplateDirective, "[ng-option-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgOptgroupTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgOptgroupTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgOptgroupTemplateDirective, "[ng-optgroup-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgLabelTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgLabelTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgLabelTemplateDirective, "[ng-label-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgMultiLabelTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgMultiLabelTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgMultiLabelTemplateDirective, "[ng-multi-label-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgHeaderTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgHeaderTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgHeaderTemplateDirective, "[ng-header-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgFooterTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgFooterTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgFooterTemplateDirective, "[ng-footer-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgNotFoundTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgNotFoundTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgNotFoundTemplateDirective, "[ng-notfound-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgTypeToSearchTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgTypeToSearchTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgTypeToSearchTemplateDirective, "[ng-typetosearch-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgLoadingTextTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgLoadingTextTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgLoadingTextTemplateDirective, "[ng-loadingtext-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgTagTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgTagTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgTagTemplateDirective, "[ng-tag-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgLoadingSpinnerTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgLoadingSpinnerTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgLoadingSpinnerTemplateDirective, "[ng-loadingspinner-tmp]", never, {}, {}, never, never, true, never>;
+}
+declare class NgClearButtonTemplateDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgClearButtonTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgClearButtonTemplateDirective, "[ng-clearbutton-tmp]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks a template as form helper text projected into a form field.
+ *
+ * @example
+ * ```html
+ * <hub-input formControlName="email">
+ *   <ng-template hubFormText>We'll never share your email.</ng-template>
+ * </hub-input>
+ * ```
+ */
+declare class HubFormTextDirective {
+    /** Template reference for the helper text. */
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubFormTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubFormTextDirective, "[hubFormText]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks a template as the legend content of a `<hub-fieldset>`.
+ *
+ * @example
+ * ```html
+ * <hub-fieldset formGroupName="address">
+ *   <ng-template hubLegend>Shipping address <span class="badge">required</span></ng-template>
+ * </hub-fieldset>
+ * ```
+ */
+declare class HubLegendDirective {
+    /** Template reference for the legend content. */
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubLegendDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubLegendDirective, "[hubLegend]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Auto-resizes a `<textarea>` to fit its content height.
+ *
+ * @example
+ * ```html
+ * <textarea hubAutoresize></textarea>
+ * ```
+ */
+declare class HubAutoresizeDirective implements OnInit {
+    #private;
+    /** Whether auto-resizing is enabled. */
+    readonly hubAutoresize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    onChange(): void;
+    ngOnInit(): void;
+    /** Resizes the textarea to fit its content. */
+    resize(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubAutoresizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubAutoresizeDirective, "textarea[hubAutoresize]", never, { "hubAutoresize": { "alias": "hubAutoresize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Inverts a HEX color, or returns the best contrasting black/white when `bw` is enabled.
+ */
+declare class HubInvertColorPipe implements PipeTransform {
+    /**
+     * @param hex - HEX color (`#rgb` or `#rrggbb`).
+     * @param bw - When `true`, returns `#000000` or `#FFFFFF` for maximum contrast.
+     * @returns The inverted (or contrasting) HEX color.
+     */
+    transform(hex: string, bw?: boolean): unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubInvertColorPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HubInvertColorPipe, "hubInvertColor", true>;
+}
+
+/**
+ * Joins an array using a separator for all but the last element, which uses a dedicated glue.
+ */
+declare class HubJoinButLastPipe implements PipeTransform {
+    /**
+     * @param values - Values to join.
+     * @param glue - Separator between all but the last element.
+     * @param lastGlue - Separator before the last element.
+     * @returns The joined string.
+     */
+    transform(values: any[], glue?: string, lastGlue?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubJoinButLastPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HubJoinButLastPipe, "hubJoinButLast", true>;
+}
+
+/**
+ * Maps an array of objects to an array of values read from a dot-separated path.
+ */
+declare class HubMapPipe implements PipeTransform {
+    /**
+     * @param value - Array of objects.
+     * @param path - Dot-separated path read from each item.
+     * @returns The array of resolved values.
+     */
+    transform(value: any[], path: string): any[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubMapPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HubMapPipe, "hubMap", true>;
+}
+
+/**
+ * Marks a URL as a trusted resource URL via the `DomSanitizer`.
+ */
+declare class HubSafeUrlPipe implements PipeTransform {
+    private readonly sanitizer;
+    /**
+     * @param value - The raw URL.
+     * @returns A `SafeUrl` trusted as a resource URL.
+     */
+    transform(value: string): SafeUrl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubSafeUrlPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HubSafeUrlPipe, "hubSafeUrl", true>;
+}
+
+/**
+ * Converts a camelCase string to UPPER_SNAKE_CASE.
+ */
+declare class HubSnakeUpperPipe implements PipeTransform {
+    /**
+     * @param value - camelCase identifier.
+     * @returns The UPPER_SNAKE_CASE representation.
+     */
+    transform(value: string): unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubSnakeUpperPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HubSnakeUpperPipe, "hubSnakeUpper", true>;
+}
+
+/**
+ * Capitalizes the first letter of a string, skipping leading non-letter characters.
+ */
+declare class HubUcfirstPipe implements PipeTransform {
+    /**
+     * @param value - Input string.
+     * @returns The string with its first letter uppercased.
+     */
+    transform(value?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubUcfirstPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HubUcfirstPipe, "hubUcfirst", true>;
+}
+
+/**
+ * Cross-field validator that checks whether two controls of a `FormGroup` hold equal values.
+ *
+ * Sets the `equal` error on the group when the values differ. Returns `null` (valid) when either
+ * control is empty, so the requirement is only enforced once both have a value.
+ *
+ * @param primaryControlName - Name of the first control.
+ * @param secondaryControlName - Name of the second control.
+ * @returns A validator function for use on a `FormGroup`.
+ *
+ * @example
+ * ```ts
+ * new FormGroup({
+ *   password: new FormControl(''),
+ *   confirm: new FormControl('')
+ * }, { validators: hubAreEqual('password', 'confirm') });
+ * ```
+ */
+declare function hubAreEqual(primaryControlName: string, secondaryControlName: string): ValidatorFn;
+
+/**
+ * Checks if a value is a string.
+ *
+ * @param value - Value to test.
+ * @returns `true` when `value` is a string.
+ */
+declare function isString(value: any): value is string;
+/**
+ * Checks if a value is defined and not null.
+ *
+ * @param value - Value to test.
+ * @returns `true` when `value` is neither `undefined` nor `null`.
+ */
+declare function isDefined(value: any): boolean;
+/**
+ * Operator that runs the source observable within a specified Angular zone.
+ *
+ * @param zone - The `NgZone` instance used to run emissions.
+ * @returns An `OperatorFunction` that re-enters the given zone for every notification.
+ */
+declare function runInZone<T>(zone: NgZone): OperatorFunction<T, T>;
+/**
+ * Joins an array of strings using a separator for all but the last element, which uses `lastSeparator`.
+ *
+ * @param texts - Strings to join.
+ * @param separator - Separator used between all but the last element. Defaults to `', '`.
+ * @param lastSeparator - Separator used before the last element. Defaults to `' and '`.
+ * @returns The joined string.
+ */
+declare function joinButLast(texts: string[], separator?: string, lastSeparator?: string): string;
+/**
+ * Checks if two values are equal, taking different types into account.
+ *
+ * Primitives are compared with strict equality; everything else is compared by JSON serialization.
+ *
+ * @param first - First value.
+ * @param second - Second value.
+ * @returns `true` when both values are considered equal.
+ */
+declare function areEqual(first: any, second: any): boolean;
+/**
+ * Checks whether a control declares a `min` or `max` validator.
+ *
+ * @param control - The control to inspect.
+ * @param type - Either `'min'` or `'max'`.
+ * @returns `true` when the validator is present.
+ */
+declare function controlHasMinOrMaxValidator(control: AbstractControl, type: 'min' | 'max'): boolean;
+/**
+ * Reads the configured `min`/`max` value from a control's validator.
+ *
+ * @param control - The control to inspect.
+ * @param type - Either `'min'` or `'max'`.
+ * @returns The configured bound, or `null` when not present.
+ */
+declare function getMinOrMaxValueFromValidator(control: AbstractControl, type: 'min' | 'max'): number | null;
+/**
+ * Retrieves a value from an object following a dot-separated path, with an optional fallback.
+ *
+ * @param object - Source object.
+ * @param path - Dot-separated path (e.g. `'a.b.c'`).
+ * @param fallback - Value returned when the path cannot be resolved. Defaults to `null`.
+ * @returns The resolved value, or the fallback.
+ */
+declare function get(object: {
+    [key: string]: any;
+}, path: string, fallback?: any): any;
+/**
+ * Converts a camelCase string to UPPER_SNAKE_CASE.
+ *
+ * @param value - camelCase identifier.
+ * @returns The UPPER_SNAKE_CASE representation.
+ */
+declare function camelToSnakeUpper(value: string): string;
+/**
+ * Generates a UUID using `crypto.randomUUID()` when available, falling back to a timestamp-based id.
+ *
+ * @returns A unique string identifier.
+ */
+declare function uuid(): string;
+/**
+ * Returns the active element within the given root, descending into shadow roots when needed.
+ *
+ * @param root - The document or shadow root to search. Defaults to `document`.
+ * @returns The deepest active element, or `null`.
+ */
+declare function getActiveElement(root?: Document | ShadowRoot): Element | null;
+
+/**
+ * Pattern-mask utilities for `hub-input`.
+ *
+ * A mask is a template string where these tokens accept user input and every other
+ * character is a literal separator that is inserted automatically as the user types:
+ *
+ * | Token | Accepts                |
+ * |-------|------------------------|
+ * | `0`   | a digit (`0`–`9`)      |
+ * | `A`   | a letter (`a`–`z`/`A`–`Z`) |
+ * | `*`   | a letter or a digit    |
+ *
+ * Examples: card `0000 0000 0000 0000`, date `00/00/0000`, IBAN `AA00 0000 0000 0000 0000 0000`,
+ * phone `+00 000 000 000`.
+ */
+/** Result of applying a mask: the formatted string and its raw (separator-free) value. */
+interface HubMaskResult {
+    /** The value formatted with literals inserted, e.g. `1234 5678`. */
+    readonly masked: string;
+    /** Only the characters that filled tokens, e.g. `12345678`. */
+    readonly unmasked: string;
+}
+/**
+ * Returns whether a mask string actually contains at least one input token.
+ *
+ * @param mask Mask template (may be empty).
+ * @returns True when the mask has a `0`, `A` or `*` token.
+ */
+declare function isMaskActive(mask: string | null | undefined): boolean;
+/**
+ * Formats a raw input string against a mask template.
+ *
+ * The input may already contain literals from a previous pass (live re-formatting):
+ * non-matching characters are skipped, and literals present in the input are consumed.
+ * Formatting stops as soon as the input is exhausted, so no trailing separators are shown
+ * before the user has typed the next character.
+ *
+ * @param value Raw user input (with or without separators).
+ * @param mask Mask template.
+ * @returns The masked and unmasked representations.
+ */
+declare function applyMask(value: string | null | undefined, mask: string): HubMaskResult;
+
+export { FormTextTypes, HUB_FORMS_CONFIG, HubAutoresizeDirective, HubDatepickerComponent, HubFieldControl, HubFieldsetComponent, HubFormComponent, HubFormControl, HubFormTextDirective, HubGroupControl, HubInputComponent, HubInputFormats, HubInvertColorPipe, HubJoinButLastPipe, HubLabelTypes, HubLegendComponent, HubLegendDirective, HubMapPipe, HubOtpInputComponent, HubSafeUrlPipe, HubSelectComponent, HubSelectFormats, HubSliderComponent, HubSnakeUpperPipe, HubTextareaComponent, HubUcfirstPipe, HubValidationErrorDirective, NgClearButtonTemplateDirective, NgFooterTemplateDirective, NgHeaderTemplateDirective, NgLabelTemplateDirective, NgLoadingSpinnerTemplateDirective, NgLoadingTextTemplateDirective, NgMultiLabelTemplateDirective, NgNotFoundTemplateDirective, NgOptgroupTemplateDirective, NgOptionComponent, NgOptionTemplateDirective, NgSelectConfig, NgTagTemplateDirective, NgTypeToSearchTemplateDirective, applyMask, areEqual, camelToSnakeUpper, controlHasMinOrMaxValidator, defaultHubDatepickerConfig, defaultHubDatepickerLabels, defaultHubFormsConfig, defaultInvalidFeedback, get, getActiveElement, getMinOrMaxValueFromValidator, hubAreEqual, isDefined, isMaskActive, isString, joinButLast, provideHubForms, runInZone, uuid };
+export type { FormTextType, HubDateRange, HubDateValue, HubDatepickerConfig, HubDatepickerLabels, HubDatepickerMode, HubFormsConfig, HubGroupErrorTrigger, HubInputFormat, HubLabelType, HubMaskResult, HubOtpMode, HubSelectFormat, HubSliderValue };