@weeehaoooz/talos-ui 0.1.0 → 0.1.2

package/types/weeehaoooz-talos-ui-form.d.ts

@@ -0,0 +1,2639 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef, InjectionToken, AfterContentChecked, OnDestroy, AfterViewInit, QueryList } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as _weeehaoooz_talos_ui_core from '@weeehaoooz/talos-ui/core';
+import { RgbaColor, HslaColor, HsvaColor, ColorFormat } from '@weeehaoooz/talos-ui/core';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+type AffixPosition = 'prefix' | 'suffix';
+type AffixAnimation = 'spin' | 'spin-once' | 'pop' | 'shake' | 'pulse' | 'bounce' | 'none';
+type AffixFeedbackState = 'success' | 'error' | null;
+/**
+ * Directive applied to leading prefix elements inside form fields, inputs, or select fields.
+ * Supports icons, symbols, dropdowns, and custom buttons.
+ */
+declare class TalosPrefixDirective {
+    private readonly elementRef;
+    /** Whether the prefix is interactive (e.g. clickable button, dropdown) */
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    /** Micro-interaction animation preset */
+    readonly animation: _angular_core.InputSignal<AffixAnimation>;
+    /** Convenience boolean signal for spinning icon / continuous refresh state */
+    readonly spinning: _angular_core.InputSignal<boolean>;
+    /** Convenience boolean signal for pop / scale bounce feedback */
+    readonly popping: _angular_core.InputSignal<boolean>;
+    /** Contextual temporary feedback state */
+    readonly feedback: _angular_core.InputSignal<AffixFeedbackState>;
+    protected isButton(): boolean;
+    protected isInteractive(): boolean;
+    get nativeElement(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosPrefixDirective, "[talosPrefix], [talos-prefix], [talosLead], [talosStart]", never, { "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "spinning": { "alias": "spinning"; "required": false; "isSignal": true; }; "popping": { "alias": "popping"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Directive applied to trailing suffix / postfix elements inside form fields, inputs, or select fields.
+ * Supports units (USD, kg, px, %), clear buttons, copy actions, and dropdown indicators.
+ */
+declare class TalosSuffixDirective {
+    private readonly elementRef;
+    /** Whether the suffix is interactive (e.g. clickable button, copy icon) */
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    /** Micro-interaction animation preset */
+    readonly animation: _angular_core.InputSignal<AffixAnimation>;
+    /** Convenience boolean signal for spinning icon / continuous refresh state */
+    readonly spinning: _angular_core.InputSignal<boolean>;
+    /** Convenience boolean signal for pop / scale bounce feedback */
+    readonly popping: _angular_core.InputSignal<boolean>;
+    /** Contextual temporary feedback state */
+    readonly feedback: _angular_core.InputSignal<AffixFeedbackState>;
+    protected isButton(): boolean;
+    protected isInteractive(): boolean;
+    get nativeElement(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosSuffixDirective, "[talosSuffix], [talosPostfix], [talos-suffix], [talos-postfix], [talosTrail], [talosEnd]", never, { "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "spinning": { "alias": "spinning"; "required": false; "isSignal": true; }; "popping": { "alias": "popping"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Convenience directive for styled text prefix elements (e.g. $, €, https://, @).
+ */
+declare class TalosTextPrefixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosTextPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosTextPrefixDirective, "[talosTextPrefix], [talos-text-prefix]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Convenience directive for styled text suffix / postfix elements (e.g. .00, USD, kg, px, %).
+ */
+declare class TalosTextSuffixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosTextSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosTextSuffixDirective, "[talosTextSuffix], [talosTextPostfix], [talos-text-suffix], [talos-text-postfix]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive explicitly applied to affix action buttons inside form fields, inputs, or select fields.
+ */
+declare class TalosAffixButtonDirective {
+    /** Micro-interaction animation preset */
+    readonly animation: _angular_core.InputSignal<AffixAnimation>;
+    /** Convenience boolean signal for spinning icon / continuous refresh state */
+    readonly spinning: _angular_core.InputSignal<boolean>;
+    /** Convenience boolean signal for pop / scale bounce feedback */
+    readonly popping: _angular_core.InputSignal<boolean>;
+    /** Contextual temporary feedback state */
+    readonly feedback: _angular_core.InputSignal<AffixFeedbackState>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAffixButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosAffixButtonDirective, "[talosAffixButton], [talos-affix-button]", never, { "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "spinning": { "alias": "spinning"; "required": false; "isSignal": true; }; "popping": { "alias": "popping"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TalosAffixModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAffixModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosAffixModule, never, [typeof TalosPrefixDirective, typeof TalosSuffixDirective, typeof TalosTextPrefixDirective, typeof TalosTextSuffixDirective, typeof TalosAffixButtonDirective], [typeof TalosPrefixDirective, typeof TalosSuffixDirective, typeof TalosTextPrefixDirective, typeof TalosTextSuffixDirective, typeof TalosAffixButtonDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosAffixModule>;
+}
+
+type AutocompleteSize = 'sm' | 'md' | 'lg';
+type AutocompleteDisplayFn<T> = (item: T) => string;
+type AutocompleteValueFn<T> = (item: T) => unknown;
+type AutocompleteFilterFn<T> = (item: T, query: string) => boolean;
+interface AutocompleteHighlightPart {
+    text: string;
+    isMatch: boolean;
+}
+interface FormattedAutocompleteOption<T = unknown> {
+    id: string;
+    label: string;
+    value: unknown;
+    raw: T;
+    highlightParts: AutocompleteHighlightPart[];
+}
+interface AutocompleteItemContext<T = unknown> {
+    $implicit: T;
+    index: number;
+    selected: boolean;
+    active: boolean;
+    highlightParts: AutocompleteHighlightPart[];
+}
+
+declare class TalosAutocompleteComponent<T = unknown> implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly options: _angular_core.InputSignal<readonly T[] | T[]>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly searching: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<AutocompleteSize>;
+    readonly minChars: _angular_core.InputSignal<number>;
+    readonly displayWith: _angular_core.InputSignal<AutocompleteDisplayFn<T> | keyof T | null>;
+    readonly valueWith: _angular_core.InputSignal<keyof T | AutocompleteValueFn<T> | null>;
+    readonly filterFn: _angular_core.InputSignal<AutocompleteFilterFn<T> | null | undefined>;
+    readonly highlightMatch: _angular_core.InputSignal<boolean>;
+    readonly noResultsText: _angular_core.InputSignal<string>;
+    readonly searchingText: _angular_core.InputSignal<string>;
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<AutocompleteItemContext<T>> | null>;
+    readonly openOnFocus: _angular_core.InputSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly searchChange: _angular_core.OutputEmitterRef<string>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<T | null>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    inputEl?: ElementRef<HTMLInputElement>;
+    dropdownEl?: ElementRef<HTMLDivElement>;
+    private readonly autoId;
+    readonly componentId: _angular_core.Signal<string>;
+    readonly inputId: _angular_core.Signal<string>;
+    readonly listboxId: _angular_core.Signal<string>;
+    readonly inputValue: _angular_core.WritableSignal<string>;
+    readonly selectedItem: _angular_core.WritableSignal<T | null>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly focusedIndex: _angular_core.WritableSignal<number>;
+    readonly isCvaDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveSearching: _angular_core.Signal<boolean>;
+    readonly formattedOptions: _angular_core.Signal<FormattedAutocompleteOption<T>[]>;
+    readonly activeOptionId: _angular_core.Signal<string | undefined>;
+    private onChange;
+    private onTouched;
+    constructor();
+    getDisplayLabel(item: T | null): string;
+    extractValue(item: T | null): unknown;
+    private computeHighlightParts;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    onInputClick(): void;
+    onTriggerClick(): void;
+    onClear(event: MouseEvent): void;
+    selectOption(opt: FormattedAutocompleteOption<T>, event?: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private scrollToFocusedOption;
+    openDropdown(): void;
+    closeDropdown(): void;
+    onDocumentClick(event: MouseEvent): void;
+    private markAsTouched;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAutocompleteComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosAutocompleteComponent<any>, "talos-autocomplete", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "searching": { "alias": "searching"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "minChars": { "alias": "minChars"; "required": false; "isSignal": true; }; "displayWith": { "alias": "displayWith"; "required": false; "isSignal": true; }; "valueWith": { "alias": "valueWith"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "highlightMatch": { "alias": "highlightMatch"; "required": false; "isSignal": true; }; "noResultsText": { "alias": "noResultsText"; "required": false; "isSignal": true; }; "searchingText": { "alias": "searchingText"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "openOnFocus": { "alias": "openOnFocus"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "searchChange": "searchChange"; "selectionChange": "selectionChange"; "opened": "opened"; "closed": "closed"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+/**
+ * Convenience NgModule wrapping the standalone TalosAutocompleteComponent.
+ */
+declare class TalosAutocompleteModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAutocompleteModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosAutocompleteModule, never, [typeof TalosAutocompleteComponent], [typeof TalosAutocompleteComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosAutocompleteModule>;
+}
+
+type CheckboxDirection = 'vertical' | 'horizontal';
+declare class TalosCheckboxGroupDirective implements ControlValueAccessor {
+    readonly elementRef: ElementRef<any>;
+    /** Name attribute for the checkbox group */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Size applied to all child checkboxes unless overridden */
+    readonly size: _angular_core.InputSignal<CheckboxSize>;
+    /** Visual color variant applied to all child checkboxes */
+    readonly variant: _angular_core.InputSignal<CheckboxVariant>;
+    /** Layout direction of checkboxes within group */
+    readonly direction: _angular_core.InputSignal<CheckboxDirection>;
+    /** Whether the entire checkbox group is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the group is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Emits when group selection array changes */
+    readonly valueChange: _angular_core.OutputEmitterRef<any[]>;
+    readonly value: _angular_core.WritableSignal<any[]>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    /** Effective disabled state taking into account CVA and input */
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(val: any[]): void;
+    registerOnChange(fn: (val: any[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Helper to check if a specific item value is currently selected in group */
+    isValueSelected(val: any): boolean;
+    /** Toggles the selection status of a value in the group array */
+    toggleValue(val: any): void;
+    /** Selects all passed values */
+    selectAll(values: any[]): void;
+    /** Deselects all values */
+    deselectAll(): void;
+    markAsTouched(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosCheckboxGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosCheckboxGroupDirective, "[talosCheckboxGroup], [talos-checkbox-group]", ["talosCheckboxGroup"], { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+type CheckboxSize = 'sm' | 'md' | 'lg';
+type CheckboxVariant = 'primary' | 'secondary' | 'success' | 'danger';
+declare class TalosCheckboxDirective {
+    private readonly elementRef;
+    readonly groupDir: TalosCheckboxGroupDirective | null;
+    /** Value associated with this checkbox when part of a group */
+    readonly value: _angular_core.InputSignal<any>;
+    /** Standalone checked state */
+    readonly checked: _angular_core.InputSignal<boolean>;
+    /** Sizing variation for the checkbox */
+    readonly size: _angular_core.InputSignal<CheckboxSize>;
+    /** Visual color variant for the checkbox */
+    readonly variant: _angular_core.InputSignal<CheckboxVariant>;
+    /** Whether the checkbox is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the checkbox is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the checkbox is in an indeterminate visual & property state */
+    readonly indeterminate: _angular_core.InputSignal<boolean>;
+    /** Output event emitted when checked state changes */
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly effectiveSize: _angular_core.Signal<CheckboxSize>;
+    readonly effectiveVariant: _angular_core.Signal<CheckboxVariant>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    readonly isChecked: _angular_core.Signal<boolean>;
+    constructor();
+    onNativeChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosCheckboxDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosCheckboxDirective, "input[type=\"checkbox\"][talosCheckbox], input[type=\"checkbox\"][talos-checkbox]", ["talosCheckbox"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+}
+
+declare class TalosCheckboxGroupComponent {
+    readonly groupDir: TalosCheckboxGroupDirective;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<CheckboxSize>;
+    readonly variant: _angular_core.InputSignal<CheckboxVariant>;
+    readonly direction: _angular_core.InputSignal<CheckboxDirection>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<any[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosCheckboxGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosCheckboxGroupComponent, "talos-checkbox-group", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, [{ directive: typeof TalosCheckboxGroupDirective; inputs: { "name": "name"; "size": "size"; "variant": "variant"; "direction": "direction"; "disabled": "disabled"; "invalid": "invalid"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class TalosCheckboxParentDirective {
+    private readonly elementRef;
+    private readonly checkboxDir;
+    private readonly ancestorGroup;
+    /** Optional explicit reference to a TalosCheckboxGroupDirective instance */
+    readonly group: _angular_core.InputSignal<TalosCheckboxGroupDirective | undefined>;
+    /** List of all selectable values for the parent checkbox to manage */
+    readonly values: _angular_core.InputSignal<any[]>;
+    /** Effective active checkbox group */
+    readonly targetGroup: _angular_core.Signal<TalosCheckboxGroupDirective | null>;
+    /** Whether all target values are selected */
+    readonly isAllSelected: _angular_core.Signal<boolean>;
+    /** Whether some (but not all) target values are selected */
+    readonly isIndeterminate: _angular_core.Signal<boolean>;
+    constructor();
+    onParentToggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosCheckboxParentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosCheckboxParentDirective, "input[type=\"checkbox\"][talosCheckboxParent], input[type=\"checkbox\"][talos-checkbox-parent], input[type=\"checkbox\"][talosSelectAll], input[type=\"checkbox\"][talos-select-all]", ["talosCheckboxParent"], { "group": { "alias": "group"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TalosCheckboxComponent implements ControlValueAccessor {
+    private readonly inputRef;
+    readonly groupDir: TalosCheckboxGroupDirective | null;
+    /** Value associated with this checkbox when part of a group */
+    readonly value: _angular_core.InputSignal<any>;
+    /** Standalone checked state */
+    readonly checked: _angular_core.InputSignal<boolean>;
+    /** Sizing variation for the checkbox */
+    readonly size: _angular_core.InputSignal<CheckboxSize>;
+    /** Visual color variant for the checkbox */
+    readonly variant: _angular_core.InputSignal<CheckboxVariant>;
+    /** Whether the checkbox is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the checkbox is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the checkbox is in an indeterminate visual & property state */
+    readonly indeterminate: _angular_core.InputSignal<boolean>;
+    /** Emitted when checked state changes */
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly internalValue: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly effectiveSize: _angular_core.Signal<CheckboxSize>;
+    readonly effectiveVariant: _angular_core.Signal<CheckboxVariant>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    readonly isChecked: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(val: boolean): void;
+    registerOnChange(fn: (val: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onDirectiveCheckedChange(isChecked: boolean): void;
+    markAsTouched(): void;
+    /** Focuses the native HTML input element */
+    focusInput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosCheckboxComponent, "talos-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Convenience NgModule wrapping standalone checkbox directives and components.
+ *
+ * Allows developers who prefer `TalosCheckboxModule` to import all checkbox utilities in one go.
+ */
+declare class TalosCheckboxModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosCheckboxModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosCheckboxModule, never, [typeof TalosCheckboxDirective, typeof TalosCheckboxGroupDirective, typeof TalosCheckboxGroupComponent, typeof TalosCheckboxParentDirective, typeof TalosCheckboxComponent], [typeof TalosCheckboxDirective, typeof TalosCheckboxGroupDirective, typeof TalosCheckboxGroupComponent, typeof TalosCheckboxParentDirective, typeof TalosCheckboxComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosCheckboxModule>;
+}
+
+type ChipSize = 'sm' | 'md' | 'lg';
+type ChipVariant = 'filled' | 'outline' | 'subtle';
+type ChipColor = 'primary' | 'neutral' | 'success' | 'warning' | 'error' | 'indigo' | 'purple' | 'cyan';
+type ChipDisplayFn<T> = (item: T) => string;
+type ChipValueFn<T> = (item: T) => unknown;
+type ChipFilterFn<T> = (item: T, search: string) => boolean;
+interface ChipHighlightPart {
+    text: string;
+    matched: boolean;
+}
+interface FormattedChipOption<T = unknown> {
+    item: T;
+    display: string;
+    value: unknown;
+    disabled: boolean;
+    selected: boolean;
+    parts: ChipHighlightPart[];
+}
+interface ChipItemContext<T = unknown> {
+    $implicit: T;
+    display: string;
+    selected: boolean;
+    disabled: boolean;
+}
+
+declare class TalosChipComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly size: _angular_core.InputSignal<ChipSize>;
+    readonly variant: _angular_core.InputSignal<ChipVariant>;
+    readonly color: _angular_core.InputSignal<ChipColor>;
+    readonly removable: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly avatarUrl: _angular_core.InputSignal<string>;
+    readonly removeAriaLabel: _angular_core.InputSignal<string>;
+    readonly removed: _angular_core.OutputEmitterRef<unknown>;
+    readonly chipClick: _angular_core.OutputEmitterRef<unknown>;
+    readonly hasAvatar: _angular_core.Signal<boolean>;
+    onChipClick(event: MouseEvent): void;
+    onRemove(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosChipComponent, "talos-chip", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "avatarUrl": { "alias": "avatarUrl"; "required": false; "isSignal": true; }; "removeAriaLabel": { "alias": "removeAriaLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; "chipClick": "chipClick"; }, never, ["*"], true, never>;
+}
+
+interface SelectedChipData {
+    display: string;
+    value: unknown;
+    originalItem: unknown;
+}
+declare class TalosChipsComponent<T = unknown> implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly options: _angular_core.InputSignal<readonly T[] | T[]>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly searching: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly removable: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<ChipSize>;
+    readonly maxChips: _angular_core.InputSignal<number | null>;
+    readonly allowCustom: _angular_core.InputSignal<boolean>;
+    readonly separatorKeys: _angular_core.InputSignal<string[]>;
+    readonly displayWith: _angular_core.InputSignal<ChipDisplayFn<T> | keyof T | null>;
+    readonly valueWith: _angular_core.InputSignal<keyof T | ChipValueFn<T> | null>;
+    readonly filterFn: _angular_core.InputSignal<ChipFilterFn<T> | null | undefined>;
+    readonly highlightMatch: _angular_core.InputSignal<boolean>;
+    readonly noResultsText: _angular_core.InputSignal<string>;
+    readonly searchingText: _angular_core.InputSignal<string>;
+    readonly chipVariant: _angular_core.InputSignal<ChipVariant>;
+    readonly chipColor: _angular_core.InputSignal<ChipColor>;
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<ChipItemContext<T>> | null>;
+    readonly openOnFocus: _angular_core.InputSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly search: _angular_core.OutputEmitterRef<string>;
+    readonly searchChange: _angular_core.OutputEmitterRef<string>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<unknown[]>;
+    readonly chipAdd: _angular_core.OutputEmitterRef<unknown>;
+    readonly chipRemove: _angular_core.OutputEmitterRef<unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    inputEl?: ElementRef<HTMLInputElement>;
+    dropdownEl?: ElementRef<HTMLDivElement>;
+    private readonly autoId;
+    readonly componentId: _angular_core.Signal<string>;
+    readonly inputId: _angular_core.Signal<string>;
+    readonly listboxId: _angular_core.Signal<string>;
+    readonly inputValue: _angular_core.WritableSignal<string>;
+    readonly selectedValues: _angular_core.WritableSignal<unknown[]>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly activeIndex: _angular_core.WritableSignal<number>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly isInputFocused: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveSearching: _angular_core.Signal<boolean>;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    readonly isMaxReached: _angular_core.Signal<boolean>;
+    readonly effectivePlaceholder: _angular_core.Signal<string>;
+    readonly activeOptionId: _angular_core.Signal<string | null>;
+    readonly selectedChips: _angular_core.Signal<SelectedChipData[]>;
+    readonly filteredOptions: _angular_core.Signal<FormattedChipOption<T>[]>;
+    constructor();
+    writeValue(value: unknown[] | unknown | null): void;
+    registerOnChange(fn: (val: unknown[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    getItemDisplay(item: T): string;
+    getItemValue(item: T): unknown;
+    private computeHighlightParts;
+    private escapeRegex;
+    onContainerClick(event: MouseEvent): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    toggleOption(option: FormattedChipOption<T>): void;
+    addCustomChip(text: string): void;
+    removeChip(chipData: SelectedChipData): void;
+    clearAll(event?: MouseEvent): void;
+    toggleDropdown(event?: MouseEvent): void;
+    openDropdown(): void;
+    closeDropdown(): void;
+    onDocumentClick(event: MouseEvent): void;
+    private emitSearch;
+    private emitSelection;
+    private markAsTouched;
+    private scrollActiveOptionIntoView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosChipsComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosChipsComponent<any>, "talos-chips", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "searching": { "alias": "searching"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "maxChips": { "alias": "maxChips"; "required": false; "isSignal": true; }; "allowCustom": { "alias": "allowCustom"; "required": false; "isSignal": true; }; "separatorKeys": { "alias": "separatorKeys"; "required": false; "isSignal": true; }; "displayWith": { "alias": "displayWith"; "required": false; "isSignal": true; }; "valueWith": { "alias": "valueWith"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "highlightMatch": { "alias": "highlightMatch"; "required": false; "isSignal": true; }; "noResultsText": { "alias": "noResultsText"; "required": false; "isSignal": true; }; "searchingText": { "alias": "searchingText"; "required": false; "isSignal": true; }; "chipVariant": { "alias": "chipVariant"; "required": false; "isSignal": true; }; "chipColor": { "alias": "chipColor"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "openOnFocus": { "alias": "openOnFocus"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "search": "search"; "searchChange": "searchChange"; "selectionChange": "selectionChange"; "chipAdd": "chipAdd"; "chipRemove": "chipRemove"; "opened": "opened"; "closed": "closed"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+declare class TalosChipsModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosChipsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosChipsModule, never, [typeof TalosChipsComponent, typeof TalosChipComponent], [typeof TalosChipsComponent, typeof TalosChipComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosChipsModule>;
+}
+
+type ColorPickerSize = 'sm' | 'md' | 'lg';
+interface ColorPresetGroup {
+    label: string;
+    colors: string[];
+}
+type ColorPresetItem = string | ColorPresetGroup;
+interface ColorChangeEvent {
+    /** The formatted string representation according to the current format */
+    value: string;
+    /** Normalized HEX string (with alpha if applicable) */
+    hex: string;
+    /** RGBA representation */
+    rgba: RgbaColor;
+    /** HSLA representation */
+    hsla: HslaColor;
+    /** HSVA representation */
+    hsva: HsvaColor;
+}
+declare const DEFAULT_COLOR_PRESETS: ColorPresetGroup[];
+
+declare class TalosColorPickerComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly format: _angular_core.InputSignal<ColorFormat>;
+    readonly showAlpha: _angular_core.InputSignal<boolean>;
+    readonly presets: _angular_core.InputSignal<ColorPresetItem[]>;
+    readonly showPresets: _angular_core.InputSignal<boolean>;
+    readonly showRecent: _angular_core.InputSignal<boolean>;
+    readonly showEyeDropper: _angular_core.InputSignal<boolean>;
+    readonly showInputs: _angular_core.InputSignal<boolean>;
+    readonly showFormatSwitcher: _angular_core.InputSignal<boolean>;
+    readonly inline: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<ColorPickerSize>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly colorChange: _angular_core.OutputEmitterRef<string>;
+    readonly colorDetailsChange: _angular_core.OutputEmitterRef<ColorChangeEvent>;
+    readonly formatChange: _angular_core.OutputEmitterRef<ColorFormat>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    satValCanvas?: ElementRef<HTMLDivElement>;
+    hueTrack?: ElementRef<HTMLDivElement>;
+    alphaTrack?: ElementRef<HTMLDivElement>;
+    triggerBtn?: ElementRef<HTMLButtonElement>;
+    triggerInput?: ElementRef<HTMLInputElement>;
+    private readonly autoId;
+    readonly componentId: _angular_core.Signal<string>;
+    readonly inputId: _angular_core.Signal<string>;
+    readonly formControlDisabled: _angular_core.WritableSignal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly isInputFocused: _angular_core.WritableSignal<boolean>;
+    readonly manualInputValue: _angular_core.WritableSignal<string>;
+    readonly currentHsva: _angular_core.WritableSignal<HsvaColor>;
+    readonly currentFormat: _angular_core.WritableSignal<ColorFormat>;
+    readonly recentColors: _angular_core.WritableSignal<string[]>;
+    readonly copied: _angular_core.WritableSignal<boolean>;
+    readonly inputHex: _angular_core.WritableSignal<string>;
+    readonly inputR: _angular_core.WritableSignal<number>;
+    readonly inputG: _angular_core.WritableSignal<number>;
+    readonly inputB: _angular_core.WritableSignal<number>;
+    readonly inputA: _angular_core.WritableSignal<number>;
+    readonly inputH: _angular_core.WritableSignal<number>;
+    readonly inputS: _angular_core.WritableSignal<number>;
+    readonly inputL: _angular_core.WritableSignal<number>;
+    private isDraggingSatVal;
+    private isDraggingHue;
+    private isDraggingAlpha;
+    readonly overlayPositions: ConnectedPosition[];
+    readonly currentRgba: _angular_core.Signal<RgbaColor>;
+    readonly currentHsla: _angular_core.Signal<_weeehaoooz_talos_ui_core.HslaColor>;
+    readonly currentHex: _angular_core.Signal<string>;
+    readonly pureHueHex: _angular_core.Signal<string>;
+    readonly isLight: _angular_core.Signal<boolean>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    readonly formattedColor: _angular_core.Signal<string>;
+    readonly rgbaString: _angular_core.Signal<string>;
+    readonly hasEyeDropper: _angular_core.Signal<boolean>;
+    readonly normalizedPresets: _angular_core.Signal<ColorPresetGroup[]>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private setColorFromExternal;
+    private updateHsva;
+    private notifyColorChange;
+    toggleDropdown(event?: Event): void;
+    open(): void;
+    close(): void;
+    onDocumentClick(event: MouseEvent): void;
+    clear(event?: MouseEvent): void;
+    onTriggerFocus(): void;
+    onTriggerBlur(event: FocusEvent): void;
+    onTriggerInput(event: Event): void;
+    onTriggerEnter(event: Event): void;
+    onSatValMouseDown(event: MouseEvent): void;
+    onSatValTouchStart(event: TouchEvent): void;
+    private updateSatValFromCoord;
+    onSatValKeyDown(event: KeyboardEvent): void;
+    onHueMouseDown(event: MouseEvent): void;
+    onHueTouchStart(event: TouchEvent): void;
+    private updateHueFromCoord;
+    onHueKeyDown(event: KeyboardEvent): void;
+    onAlphaMouseDown(event: MouseEvent): void;
+    onAlphaTouchStart(event: TouchEvent): void;
+    private updateAlphaFromCoord;
+    onAlphaKeyDown(event: KeyboardEvent): void;
+    pickWithEyeDropper(): Promise<void>;
+    copyColor(): Promise<void>;
+    switchFormat(format: ColorFormat): void;
+    onHexInputChange(val: string): void;
+    onRgbaInputChange(): void;
+    onHslaInputChange(): void;
+    selectPreset(color: string): void;
+    private recordRecentColor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosColorPickerComponent, "talos-color-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "showAlpha": { "alias": "showAlpha"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "showPresets": { "alias": "showPresets"; "required": false; "isSignal": true; }; "showRecent": { "alias": "showRecent"; "required": false; "isSignal": true; }; "showEyeDropper": { "alias": "showEyeDropper"; "required": false; "isSignal": true; }; "showInputs": { "alias": "showInputs"; "required": false; "isSignal": true; }; "showFormatSwitcher": { "alias": "showFormatSwitcher"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "colorChange": "colorChange"; "colorDetailsChange": "colorDetailsChange"; "formatChange": "formatChange"; "opened": "opened"; "closed": "closed"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+declare class TalosColorPickerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosColorPickerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosColorPickerModule, never, [typeof TalosColorPickerComponent], [typeof TalosColorPickerComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosColorPickerModule>;
+}
+
+interface CalendarDay {
+    date: Date;
+    dayNumber: number;
+    isCurrentMonth: boolean;
+    isToday: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+    isFocused: boolean;
+}
+interface CalendarMonth {
+    name: string;
+    monthIndex: number;
+    isSelected: boolean;
+    isCurrentMonth: boolean;
+    isDisabled: boolean;
+}
+interface CalendarYear {
+    year: number;
+    isSelected: boolean;
+    isCurrentYear: boolean;
+    isDisabled: boolean;
+}
+declare class DatePickerComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly displayFormat: _angular_core.InputSignal<string>;
+    readonly valueFormat: _angular_core.InputSignal<string>;
+    readonly showTime: _angular_core.InputSignal<boolean>;
+    readonly use24Hour: _angular_core.InputSignal<boolean>;
+    readonly showSeconds: _angular_core.InputSignal<boolean>;
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    readonly minDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly maxDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly firstDayOfWeek: _angular_core.InputSignal<number>;
+    readonly filterDate: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    readonly dateChange: _angular_core.OutputEmitterRef<unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    triggerEl?: ElementRef<HTMLDivElement>;
+    inputEl?: ElementRef<HTMLInputElement>;
+    readonly positions: ConnectedPosition[];
+    readonly componentId: string;
+    readonly dialogId: string;
+    readonly selectedDate: _angular_core.WritableSignal<Date | null>;
+    readonly viewDate: _angular_core.WritableSignal<Date>;
+    readonly viewMode: _angular_core.WritableSignal<"day" | "month" | "year">;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly focusedDate: _angular_core.WritableSignal<Date | null>;
+    readonly inputText: _angular_core.WritableSignal<string>;
+    readonly draftHour: _angular_core.WritableSignal<number>;
+    readonly draftMinute: _angular_core.WritableSignal<number>;
+    readonly draftSecond: _angular_core.WritableSignal<number>;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveDisplayFormat: _angular_core.Signal<string>;
+    readonly effectiveValueFormat: _angular_core.Signal<string>;
+    readonly formattedValue: _angular_core.Signal<string>;
+    readonly displayHour: _angular_core.Signal<string>;
+    readonly displayMinute: _angular_core.Signal<string>;
+    readonly displaySecond: _angular_core.Signal<string>;
+    readonly meridiem: _angular_core.Signal<"AM" | "PM">;
+    readonly parsedMinDate: _angular_core.Signal<Date | null>;
+    readonly parsedMaxDate: _angular_core.Signal<Date | null>;
+    readonly weekDayNames: _angular_core.Signal<string[]>;
+    readonly calendarDays: _angular_core.Signal<CalendarDay[]>;
+    readonly monthList: _angular_core.Signal<CalendarMonth[]>;
+    readonly yearList: _angular_core.Signal<CalendarYear[]>;
+    readonly isPrevDisabled: _angular_core.Signal<boolean>;
+    readonly isNextDisabled: _angular_core.Signal<boolean>;
+    readonly isTodayDisabled: _angular_core.Signal<boolean>;
+    readonly isNowDisabled: _angular_core.Signal<boolean>;
+    readonly currentHeaderLabel: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggleOpen(): void;
+    open(): void;
+    close(): void;
+    prevPeriod(): void;
+    nextPeriod(): void;
+    toggleViewMode(): void;
+    selectMonth(monthIdx: number): void;
+    selectYear(year: number): void;
+    selectDay(day: CalendarDay): void;
+    selectToday(): void;
+    selectNow(): void;
+    applySelection(): void;
+    adjustHour(delta: number): void;
+    adjustMinute(delta: number): void;
+    adjustSecond(delta: number): void;
+    onHourInput(event: Event): void;
+    onHourBlur(event: FocusEvent): void;
+    onMinuteInput(event: Event): void;
+    onMinuteBlur(event: FocusEvent): void;
+    onSecondInput(event: Event): void;
+    onSecondBlur(event: FocusEvent): void;
+    onTimeInputKeydown(event: KeyboardEvent, type: 'hour' | 'minute' | 'second'): void;
+    toggleMeridiem(): void;
+    private updateSelectedTime;
+    onClear(event: MouseEvent): void;
+    onInputChange(event: Event): void;
+    onInputFocus(): void;
+    onInputBlur(event: FocusEvent): void;
+    onInputKeyDown(event: KeyboardEvent): void;
+    private commitSelection;
+    private formatOutputValue;
+    private isDateDisabled;
+    markAsTouched(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private navigateKeyboardDay;
+    onDocumentClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerComponent, "talos-date-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "use24Hour": { "alias": "use24Hour"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "filterDate": { "alias": "filterDate"; "required": false; "isSignal": true; }; }, { "dateChange": "dateChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+interface DateRangeValue {
+    startDate: string | Date | number | null;
+    endDate: string | Date | number | null;
+}
+interface InternalDateRange {
+    startDate: Date | null;
+    endDate: Date | null;
+}
+interface DateRangePreset {
+    label: string;
+    key?: string;
+    isDuration?: boolean;
+    getValue?: (referenceDate?: Date | null) => InternalDateRange;
+    duration?: {
+        days?: number;
+        weeks?: number;
+        months?: number;
+        years?: number;
+    };
+}
+interface RangeCalendarDay {
+    date: Date;
+    dayNumber: number;
+    isCurrentMonth: boolean;
+    isToday: boolean;
+    isSelectedStart: boolean;
+    isSelectedEnd: boolean;
+    isInRange: boolean;
+    isHoveredRange: boolean;
+    isDisabled: boolean;
+    isFocused: boolean;
+}
+
+declare class DateRangePickerComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly displayFormat: _angular_core.InputSignal<string>;
+    readonly valueFormat: _angular_core.InputSignal<string>;
+    readonly showTime: _angular_core.InputSignal<boolean>;
+    readonly use24Hour: _angular_core.InputSignal<boolean>;
+    readonly showSeconds: _angular_core.InputSignal<boolean>;
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    readonly minDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly maxDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly minSpan: _angular_core.InputSignal<number | null>;
+    readonly maxSpan: _angular_core.InputSignal<number | null>;
+    readonly firstDayOfWeek: _angular_core.InputSignal<number>;
+    readonly presets: _angular_core.InputSignal<DateRangePreset[] | null>;
+    readonly presetType: _angular_core.InputSignal<"all" | "calendar" | "duration">;
+    readonly filterDate: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    readonly rangeChange: _angular_core.OutputEmitterRef<DateRangeValue | null>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    triggerEl?: ElementRef<HTMLDivElement>;
+    startInputEl?: ElementRef<HTMLInputElement>;
+    endInputEl?: ElementRef<HTMLInputElement>;
+    readonly positions: ConnectedPosition[];
+    readonly componentId: string;
+    readonly dialogId: string;
+    readonly selectedStartDate: _angular_core.WritableSignal<Date | null>;
+    readonly selectedEndDate: _angular_core.WritableSignal<Date | null>;
+    readonly draftStartDate: _angular_core.WritableSignal<Date | null>;
+    readonly draftEndDate: _angular_core.WritableSignal<Date | null>;
+    readonly hoverDate: _angular_core.WritableSignal<Date | null>;
+    readonly draftStartHour: _angular_core.WritableSignal<number>;
+    readonly draftStartMinute: _angular_core.WritableSignal<number>;
+    readonly draftStartSecond: _angular_core.WritableSignal<number>;
+    readonly draftEndHour: _angular_core.WritableSignal<number>;
+    readonly draftEndMinute: _angular_core.WritableSignal<number>;
+    readonly draftEndSecond: _angular_core.WritableSignal<number>;
+    readonly viewDate: _angular_core.WritableSignal<Date>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly isDisabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly activePresetLabel: _angular_core.WritableSignal<string | null>;
+    readonly startInputText: _angular_core.WritableSignal<string>;
+    readonly endInputText: _angular_core.WritableSignal<string>;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveDisplayFormat: _angular_core.Signal<string>;
+    readonly effectiveValueFormat: _angular_core.Signal<string>;
+    readonly viewDateRight: _angular_core.Signal<Date>;
+    readonly parsedMinDate: _angular_core.Signal<Date | null>;
+    readonly parsedMaxDate: _angular_core.Signal<Date | null>;
+    readonly formattedTriggerValue: _angular_core.Signal<string>;
+    readonly weekDayNames: _angular_core.Signal<string[]>;
+    readonly effectivePresets: _angular_core.Signal<DateRangePreset[]>;
+    readonly leftCalendarDays: _angular_core.Signal<RangeCalendarDay[]>;
+    readonly rightCalendarDays: _angular_core.Signal<RangeCalendarDay[]>;
+    readonly isPrevDisabled: _angular_core.Signal<boolean>;
+    readonly isNextDisabled: _angular_core.Signal<boolean>;
+    readonly leftHeaderLabel: _angular_core.Signal<string>;
+    readonly rightHeaderLabel: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggleOpen(): void;
+    open(): void;
+    close(): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    selectDay(day: RangeCalendarDay): void;
+    onDayHover(day: RangeCalendarDay): void;
+    applyPreset(preset: DateRangePreset): void;
+    applySelection(): void;
+    cancelSelection(): void;
+    onClear(event: MouseEvent): void;
+    adjustStartHour(delta: number): void;
+    adjustStartMinute(delta: number): void;
+    adjustEndHour(delta: number): void;
+    adjustEndMinute(delta: number): void;
+    toggleStartMeridiem(): void;
+    toggleEndMeridiem(): void;
+    onStartInputChange(event: Event): void;
+    onStartInputBlur(event: FocusEvent): void;
+    onEndInputChange(event: Event): void;
+    onEndInputBlur(event: FocusEvent): void;
+    onFooterInputKeyDown(event: KeyboardEvent): void;
+    private buildCalendarDays;
+    private emitValue;
+    private formatOutputDate;
+    markAsTouched(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onDocumentClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangePickerComponent, "talos-date-range-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "use24Hour": { "alias": "use24Hour"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "minSpan": { "alias": "minSpan"; "required": false; "isSignal": true; }; "maxSpan": { "alias": "maxSpan"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "presetType": { "alias": "presetType"; "required": false; "isSignal": true; }; "filterDate": { "alias": "filterDate"; "required": false; "isSignal": true; }; }, { "rangeChange": "rangeChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class DateTimePickerComponent implements ControlValueAccessor {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly displayFormat: _angular_core.InputSignal<string>;
+    readonly valueFormat: _angular_core.InputSignal<string>;
+    readonly use24Hour: _angular_core.InputSignal<boolean>;
+    readonly showSeconds: _angular_core.InputSignal<boolean>;
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    readonly minDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly maxDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly firstDayOfWeek: _angular_core.InputSignal<number>;
+    readonly filterDate: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    readonly dateTimeChange: _angular_core.OutputEmitterRef<unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    corePicker?: DatePickerComponent;
+    readonly componentId: string;
+    readonly currentValue: _angular_core.WritableSignal<unknown>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onDateChange(val: unknown): void;
+    onOpened(): void;
+    onClosed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateTimePickerComponent, "talos-date-time-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "use24Hour": { "alias": "use24Hour"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "filterDate": { "alias": "filterDate"; "required": false; "isSignal": true; }; }, { "dateTimeChange": "dateTimeChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class DateTimeRangePickerComponent implements ControlValueAccessor {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly displayFormat: _angular_core.InputSignal<string>;
+    readonly valueFormat: _angular_core.InputSignal<string>;
+    readonly use24Hour: _angular_core.InputSignal<boolean>;
+    readonly showSeconds: _angular_core.InputSignal<boolean>;
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    readonly minDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly maxDate: _angular_core.InputSignal<string | number | Date | null>;
+    readonly minSpan: _angular_core.InputSignal<number | null>;
+    readonly maxSpan: _angular_core.InputSignal<number | null>;
+    readonly firstDayOfWeek: _angular_core.InputSignal<number>;
+    readonly presets: _angular_core.InputSignal<DateRangePreset[] | null>;
+    readonly presetType: _angular_core.InputSignal<"all" | "calendar" | "duration">;
+    readonly filterDate: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    readonly dateTimeRangeChange: _angular_core.OutputEmitterRef<DateRangeValue | null>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    corePicker?: DateRangePickerComponent;
+    readonly componentId: string;
+    readonly currentValue: _angular_core.WritableSignal<DateRangeValue | null>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onRangeChange(val: DateRangeValue | null): void;
+    onOpened(): void;
+    onClosed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeRangePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateTimeRangePickerComponent, "talos-date-time-range-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "use24Hour": { "alias": "use24Hour"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "minSpan": { "alias": "minSpan"; "required": false; "isSignal": true; }; "maxSpan": { "alias": "maxSpan"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "presetType": { "alias": "presetType"; "required": false; "isSignal": true; }; "filterDate": { "alias": "filterDate"; "required": false; "isSignal": true; }; }, { "dateTimeRangeChange": "dateTimeRangeChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Status of a file being tracked or uploaded in the Drop Zone.
+ */
+type DropZoneFileStatus = 'pending' | 'uploading' | 'success' | 'error';
+/**
+ * Visual layout variants for the Drop Zone.
+ */
+type DropZoneVariant = 'default' | 'compact' | 'mini' | 'card';
+/**
+ * Size variants for the Drop Zone.
+ */
+type DropZoneSize = 'sm' | 'md' | 'lg';
+/**
+ * Rejection reason codes when an added file fails validation.
+ */
+type FileRejectionReason = 'INVALID_TYPE' | 'FILE_TOO_LARGE' | 'FILE_TOO_SMALL' | 'MAX_FILES_EXCEEDED' | 'DUPLICATE_FILE' | 'CUSTOM_VALIDATION_FAILED';
+/**
+ * Information regarding a file rejected during drag & drop or selection.
+ */
+interface DropZoneRejection {
+    file: File;
+    reason: FileRejectionReason;
+    message: string;
+}
+/**
+ * Wrapper object representing an uploaded or staged file in the Drop Zone.
+ */
+interface DropZoneFile {
+    id: string;
+    file: File;
+    name: string;
+    size: number;
+    type: string;
+    progress?: number;
+    status?: DropZoneFileStatus;
+    errorMessage?: string;
+    previewUrl?: string;
+    data?: unknown;
+}
+/**
+ * Custom file validation function. Returns null if valid or an error message string if invalid.
+ */
+type DropZoneValidatorFn = (file: File) => string | null;
+/**
+ * Event payload emitted when files are dropped or selected.
+ */
+interface DropZoneChangeEvent {
+    files: DropZoneFile[];
+    rawFiles: File[];
+    rejected: DropZoneRejection[];
+}
+
+declare class TalosFileDropDirective {
+    private readonly elementRef;
+    /** Whether the drop target is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Signal emitting when files are dropped onto the element */
+    readonly fileDrop: _angular_core.OutputEmitterRef<File[]>;
+    /** Signal emitting when a drag enters the element */
+    readonly dragOver: _angular_core.OutputEmitterRef<DragEvent>;
+    /** Signal emitting when a drag leaves the element */
+    readonly dragLeave: _angular_core.OutputEmitterRef<DragEvent>;
+    /** Internal signal tracking active drag over state */
+    readonly isDragOver: _angular_core.WritableSignal<boolean>;
+    /** Counter to handle dragenter/dragleave transitions between child elements */
+    private dragCounter;
+    onDragOver(event: DragEvent): void;
+    onDragEnter(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosFileDropDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosFileDropDirective, "[talosFileDrop], [talos-file-drop]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "fileDrop": "fileDrop"; "dragOver": "dragOver"; "dragLeave": "dragLeave"; }, never, never, true, never>;
+}
+
+declare class TalosDropZoneComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    /** Accepted file types / extensions (e.g. "image/*", ".pdf,.docx", "image/png,image/jpeg") */
+    readonly accept: _angular_core.InputSignal<string>;
+    /** Allow selecting multiple files */
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    /** Maximum file size in bytes or human-readable string (e.g. 5242880 or '5MB') */
+    readonly maxFileSize: _angular_core.InputSignal<string | number | null>;
+    /** Minimum file size in bytes or human-readable string (e.g. 1024 or '1KB') */
+    readonly minFileSize: _angular_core.InputSignal<string | number | null>;
+    /** Maximum total number of files allowed */
+    readonly maxFiles: _angular_core.InputSignal<number | null>;
+    /** Disable user interactions */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Make drop zone read-only */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Display loading / processing spinner */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /** Layout visual variant */
+    readonly variant: _angular_core.InputSignal<DropZoneVariant>;
+    /** Sizing variant */
+    readonly size: _angular_core.InputSignal<DropZoneSize>;
+    /** Primary title displayed in the drop zone */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Subtitle / hint text displayed below the title */
+    readonly subTitle: _angular_core.InputSignal<string>;
+    /** Text label for the browse button/link */
+    readonly browseLabel: _angular_core.InputSignal<string>;
+    /** Secondary bottom helper text or error message */
+    readonly hint: _angular_core.InputSignal<string>;
+    /** Whether to render the built-in staged file list preview */
+    readonly showFileList: _angular_core.InputSignal<boolean>;
+    /** Automatically manage staged files in internal state when dropped/selected */
+    readonly autoManageFiles: _angular_core.InputSignal<boolean>;
+    /** Automatically generate object URL thumbnails for image files */
+    readonly autoGeneratePreviews: _angular_core.InputSignal<boolean>;
+    /** Allow removing staged files */
+    readonly removable: _angular_core.InputSignal<boolean>;
+    /** Allow retrying failed uploads */
+    readonly allowRetry: _angular_core.InputSignal<boolean>;
+    /** Custom validator function for individual files */
+    readonly validator: _angular_core.InputSignal<DropZoneValidatorFn | null>;
+    /** Custom template for rendering staged file list items */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<{
+        $implicit: DropZoneFile;
+        index: number;
+        remove: () => void;
+        retry: () => void;
+    }> | null>;
+    /** Custom template for rendering drop zone inner content */
+    readonly contentTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
+    /** Component DOM ID */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Form control name */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Staged / uploaded files model */
+    readonly files: _angular_core.ModelSignal<DropZoneFile[]>;
+    /** Emitted with raw native File objects */
+    readonly rawFilesChange: _angular_core.OutputEmitterRef<File[]>;
+    /** Emitted when files are dropped */
+    readonly fileDrop: _angular_core.OutputEmitterRef<File[]>;
+    /** Emitted when files are selected via native file dialog */
+    readonly fileSelect: _angular_core.OutputEmitterRef<File[]>;
+    /** Emitted when a file is removed */
+    readonly fileRemove: _angular_core.OutputEmitterRef<DropZoneFile>;
+    /** Emitted when a file retry button is clicked */
+    readonly fileRetry: _angular_core.OutputEmitterRef<DropZoneFile>;
+    /** Emitted when files fail validation */
+    readonly rejected: _angular_core.OutputEmitterRef<DropZoneRejection[]>;
+    /** Emitted when drag over state changes */
+    readonly dragStateChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Emitted with full change event payload */
+    readonly change: _angular_core.OutputEmitterRef<DropZoneChangeEvent>;
+    fileInput?: ElementRef<HTMLInputElement>;
+    private readonly autoId;
+    readonly componentId: _angular_core.Signal<string>;
+    readonly inputId: _angular_core.Signal<string>;
+    readonly isDragOver: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly maxSizeBytes: _angular_core.Signal<number | null>;
+    readonly minSizeBytes: _angular_core.Signal<number | null>;
+    readonly hasFiles: _angular_core.Signal<boolean>;
+    readonly isMaxFilesReached: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(value: DropZoneFile[] | File[] | File | null): void;
+    registerOnChange(fn: (value: DropZoneFile[] | File[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Opens the native file selector dialog.
+     */
+    openFileDialog(): void;
+    /**
+     * Keyboard handler on the drop zone container (Enter / Space to open browse dialog)
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Native file input change handler
+     */
+    onNativeInputChange(event: Event): void;
+    /**
+     * Handles files dropped onto the dropzone
+     */
+    onDropFiles(droppedFiles: File[]): void;
+    /**
+     * Updates drag over state
+     */
+    onDragState(isOver: boolean): void;
+    /**
+     * Removes a file from the staged list
+     */
+    removeFile(dropFile: DropZoneFile, event?: MouseEvent): void;
+    /**
+     * Retries uploading a file
+     */
+    retryFile(dropFile: DropZoneFile, event?: MouseEvent): void;
+    /**
+     * Updates the progress or status of a staged file programmatically.
+     */
+    updateFileProgress(fileId: string, progress: number, status?: DropZoneFileStatus, errorMessage?: string): void;
+    /**
+     * Clear all files from the drop zone.
+     */
+    clearFiles(): void;
+    private processFiles;
+    private validateFile;
+    private checkAccept;
+    private createDropZoneFile;
+    private emitChanges;
+    private markAsTouched;
+    parseByteSize(size: number | string | null | undefined): number | null;
+    formatBytes(bytes: number, decimals?: number): string;
+    getFileTypeCategory(file: DropZoneFile): 'image' | 'pdf' | 'doc' | 'archive' | 'audio' | 'video' | 'code' | 'generic';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDropZoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosDropZoneComponent, "talos-drop-zone, talos-file-upload", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "minFileSize": { "alias": "minFileSize"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "subTitle": { "alias": "subTitle"; "required": false; "isSignal": true; }; "browseLabel": { "alias": "browseLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "showFileList": { "alias": "showFileList"; "required": false; "isSignal": true; }; "autoManageFiles": { "alias": "autoManageFiles"; "required": false; "isSignal": true; }; "autoGeneratePreviews": { "alias": "autoGeneratePreviews"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "allowRetry": { "alias": "allowRetry"; "required": false; "isSignal": true; }; "validator": { "alias": "validator"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "contentTemplate": { "alias": "contentTemplate"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "files": "filesChange"; "rawFilesChange": "rawFilesChange"; "fileDrop": "fileDrop"; "fileSelect": "fileSelect"; "fileRemove": "fileRemove"; "fileRetry": "fileRetry"; "rejected": "rejected"; "dragStateChange": "dragStateChange"; "change": "change"; }, never, never, true, never>;
+}
+
+/**
+ * Lifecycle status of an individual file upload task.
+ */
+type UploadTaskStatus = 'idle' | 'requesting-url' | 'uploading' | 'completed' | 'error' | 'canceled';
+/**
+ * Payload sent to retrieve a pre-signed upload URL.
+ */
+interface PresignedUrlRequest {
+    file: File;
+    fileName: string;
+    fileSize: number;
+    fileType: string;
+    metadata?: Record<string, string>;
+    checksum?: string;
+}
+/**
+ * Response payload containing the pre-signed URL and upload details.
+ */
+interface PresignedUrlResponse {
+    /** The pre-signed URL to upload the file to (e.g. AWS S3, GCS, Azure Blob, or backend endpoint). */
+    uploadUrl: string;
+    /** Final public or persistent URL of the uploaded asset once complete. */
+    fileUrl?: string;
+    /** HTTP method to use for the upload. Defaults to 'PUT'. */
+    method?: 'PUT' | 'POST';
+    /** Optional custom headers required for the upload (e.g. Content-Type, x-amz-acl, etc.). */
+    headers?: Record<string, string>;
+    /** Optional multipart form data or S3 policy fields if method is 'POST'. */
+    formData?: Record<string, string | Blob>;
+    /** Optional S3 POST form fields. */
+    fields?: Record<string, string>;
+}
+/**
+ * Handler function or Observable for retrieving pre-signed URLs from the backend.
+ */
+type PresignedUrlHandlerFn = (request: PresignedUrlRequest) => Observable<PresignedUrlResponse> | Promise<PresignedUrlResponse>;
+/**
+ * Options for configuring an individual upload task.
+ */
+interface UploadFileOptions {
+    presignedHandler?: PresignedUrlHandlerFn;
+    metadata?: Record<string, string>;
+    headers?: Record<string, string>;
+    /** Auto-start upload once created. Default: true */
+    autoStart?: boolean;
+}
+/**
+ * Progress details emitted while streaming binary data to the pre-signed URL.
+ */
+interface UploadProgressEvent {
+    loaded: number;
+    total: number;
+    percentage: number;
+    speed: number;
+    speedFormatted: string;
+    timeRemaining?: number;
+}
+/**
+ * Active upload task representing a single file being uploaded to a pre-signed URL.
+ */
+interface UploadTask {
+    id: string;
+    file: File;
+    fileName: string;
+    fileSize: number;
+    fileType: string;
+    status: UploadTaskStatus;
+    progress: number;
+    loaded: number;
+    total: number;
+    speed: number;
+    speedFormatted?: string;
+    timeRemaining?: number;
+    presignedUrl?: string;
+    fileUrl?: string;
+    errorMessage?: string;
+    previewUrl?: string;
+    startedAt?: number;
+    completedAt?: number;
+    cancel?: () => void;
+    retry?: () => void;
+}
+/**
+ * Global configuration options for Talos Presigned Upload.
+ */
+interface PresignedUploadConfig {
+    /** Default backend pre-signed URL handler function */
+    getPresignedUrl?: PresignedUrlHandlerFn;
+    /** Global HTTP headers to attach to pre-signed upload requests */
+    defaultHeaders?: Record<string, string>;
+    /** Max concurrent uploads. Default: 3 */
+    maxConcurrent?: number;
+    /** Simulated latency in ms when using built-in mock mode. Default: 0 */
+    simulatedDelayMs?: number;
+}
+/**
+ * Injection token for global pre-signed upload configuration.
+ */
+declare const TALOS_PRESIGNED_UPLOAD_CONFIG: InjectionToken<PresignedUploadConfig>;
+/**
+ * Injection token for default presigned URL handler function.
+ */
+declare const TALOS_PRESIGNED_URL_HANDLER: InjectionToken<PresignedUrlHandlerFn>;
+
+declare class TalosPresignedUploadService {
+    private readonly config;
+    private readonly defaultHandler;
+    /**
+     * Creates and starts an upload task for a single file.
+     * Handles requesting the pre-signed URL and streaming binary data to it.
+     */
+    upload(file: File, options?: UploadFileOptions, onUpdate?: (task: UploadTask) => void): UploadTask;
+    /**
+     * Batch helper to create upload tasks for multiple files.
+     */
+    uploadBatch(files: File[], options?: UploadFileOptions, onUpdate?: (tasks: UploadTask[]) => void): UploadTask[];
+    /**
+     * Performs the binary transfer to the retrieved pre-signed URL via XMLHttpRequest.
+     */
+    private executeUploadToPresignedUrl;
+    /**
+     * Internal simulation runner for development and showcasing without requiring a live cloud bucket.
+     */
+    private simulateUploadProgress;
+    /**
+     * Creates a default simulated presigned URL handler if none is provided.
+     */
+    private createMockPresignedHandler;
+    /**
+     * Format bytes per second into human-readable rate (e.g. "1.2 MB/s").
+     */
+    formatSpeed(bytesPerSecond: number): string;
+    /**
+     * Format bytes into human-readable size (e.g. "2.4 MB").
+     */
+    formatBytes(bytes: number, decimals?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosPresignedUploadService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TalosPresignedUploadService>;
+}
+
+declare class TalosFileUploadProgressComponent {
+    private readonly uploadService;
+    /** Optional custom template for extra content inside each task card */
+    readonly taskContentTpl: _angular_core.Signal<TemplateRef<{
+        $implicit: UploadTask;
+        task: UploadTask;
+    }> | undefined>;
+    /** Optional custom template for extra action buttons inside each task card */
+    readonly taskActionsTpl: _angular_core.Signal<TemplateRef<{
+        $implicit: UploadTask;
+        task: UploadTask;
+    }> | undefined>;
+    /** Active list of upload tasks */
+    readonly tasks: _angular_core.InputSignal<UploadTask[]>;
+    /** Visual layout variant: 'card' (default), 'compact', or 'minimal' */
+    readonly variant: _angular_core.InputSignal<"compact" | "card" | "minimal">;
+    /** Whether to render top summary stats header */
+    readonly showSummary: _angular_core.InputSignal<boolean>;
+    /** Allow canceling in-flight uploads */
+    readonly allowCancel: _angular_core.InputSignal<boolean>;
+    /** Allow retrying failed uploads */
+    readonly allowRetry: _angular_core.InputSignal<boolean>;
+    /** Allow removing finished or failed tasks from the list */
+    readonly allowRemove: _angular_core.InputSignal<boolean>;
+    /** Show button to copy file URL upon upload completion */
+    readonly allowCopyUrl: _angular_core.InputSignal<boolean>;
+    readonly taskCancel: _angular_core.OutputEmitterRef<UploadTask>;
+    readonly taskRetry: _angular_core.OutputEmitterRef<UploadTask>;
+    readonly taskRemove: _angular_core.OutputEmitterRef<UploadTask>;
+    readonly taskComplete: _angular_core.OutputEmitterRef<UploadTask>;
+    readonly copiedTaskId: _angular_core.WritableSignal<string | null>;
+    readonly failedImageIds: _angular_core.WritableSignal<Set<string>>;
+    isImgFailed(taskId: string): boolean;
+    handleImgError(taskId: string): void;
+    readonly hasTasks: _angular_core.Signal<boolean>;
+    readonly totalCount: _angular_core.Signal<number>;
+    readonly activeCount: _angular_core.Signal<number>;
+    readonly completedCount: _angular_core.Signal<number>;
+    readonly errorCount: _angular_core.Signal<number>;
+    readonly overallPercentage: _angular_core.Signal<number>;
+    cancelTask(task: UploadTask, event?: MouseEvent): void;
+    retryTask(task: UploadTask, event?: MouseEvent): void;
+    removeTask(task: UploadTask, event?: MouseEvent): void;
+    copyFileUrl(task: UploadTask, event?: MouseEvent): void;
+    cancelAll(): void;
+    formatBytes(bytes: number): string;
+    formatTimeRemaining(seconds: number | undefined): string;
+    getFileTypeCategory(task: UploadTask): 'image' | 'pdf' | 'doc' | 'archive' | 'audio' | 'video' | 'code' | 'generic';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosFileUploadProgressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosFileUploadProgressComponent, "talos-file-upload-progress, talos-upload-progress", never, { "tasks": { "alias": "tasks"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showSummary": { "alias": "showSummary"; "required": false; "isSignal": true; }; "allowCancel": { "alias": "allowCancel"; "required": false; "isSignal": true; }; "allowRetry": { "alias": "allowRetry"; "required": false; "isSignal": true; }; "allowRemove": { "alias": "allowRemove"; "required": false; "isSignal": true; }; "allowCopyUrl": { "alias": "allowCopyUrl"; "required": false; "isSignal": true; }; }, { "taskCancel": "taskCancel"; "taskRetry": "taskRetry"; "taskRemove": "taskRemove"; "taskComplete": "taskComplete"; }, ["taskContentTpl", "taskActionsTpl"], ["[talosUploadActions], [headerExtra]", "[taskExtra], [cardExtra], [itemExtra]", "*", "[taskAction], [taskActions]"], true, never>;
+}
+
+declare class TalosPresignedFileUploadComponent {
+    private readonly uploadService;
+    /** Custom handler to retrieve pre-signed upload URLs */
+    readonly presignedHandler: _angular_core.InputSignal<PresignedUrlHandlerFn | undefined>;
+    /** Accepted MIME types or extensions (e.g. "image/*,.pdf") */
+    readonly accept: _angular_core.InputSignal<string>;
+    /** Allow multiple files selection and drag-drop */
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    /** Maximum file size in bytes or human-readable format (e.g. 5242880 or '25MB') */
+    readonly maxFileSize: _angular_core.InputSignal<string | number | null>;
+    /** Minimum file size in bytes or human-readable format */
+    readonly minFileSize: _angular_core.InputSignal<string | number | null>;
+    /** Maximum total number of files allowed simultaneously */
+    readonly maxFiles: _angular_core.InputSignal<number | null>;
+    /** Visual layout variant of the drop zone */
+    readonly variant: _angular_core.InputSignal<DropZoneVariant>;
+    /** Sizing variant of the drop zone */
+    readonly size: _angular_core.InputSignal<DropZoneSize>;
+    /** Title displayed in the drop zone */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Subtitle displayed in the drop zone */
+    readonly subTitle: _angular_core.InputSignal<string>;
+    /** Label for the browse button */
+    readonly browseLabel: _angular_core.InputSignal<string>;
+    /** Disable user interactions */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Read-only mode */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Show top summary statistics */
+    readonly showSummary: _angular_core.InputSignal<boolean>;
+    /** Allow canceling active uploads */
+    readonly allowCancel: _angular_core.InputSignal<boolean>;
+    /** Allow retrying failed uploads */
+    readonly allowRetry: _angular_core.InputSignal<boolean>;
+    /** Allow removing tasks from the list */
+    readonly allowRemove: _angular_core.InputSignal<boolean>;
+    /** Show copy URL action button on completion */
+    readonly allowCopyUrl: _angular_core.InputSignal<boolean>;
+    /** Additional custom metadata to send when requesting the pre-signed URL */
+    readonly metadata: _angular_core.InputSignal<Record<string, string> | undefined>;
+    /** Additional custom HTTP headers to pass during the binary upload */
+    readonly headers: _angular_core.InputSignal<Record<string, string> | undefined>;
+    /** Active and historical upload tasks */
+    readonly tasks: _angular_core.ModelSignal<UploadTask[]>;
+    /** Emitted when an individual file finishes uploading successfully */
+    readonly uploadComplete: _angular_core.OutputEmitterRef<UploadTask>;
+    /** Emitted when all current uploads have completed successfully */
+    readonly allCompleted: _angular_core.OutputEmitterRef<UploadTask[]>;
+    /** Emitted when an upload encounters an error */
+    readonly uploadError: _angular_core.OutputEmitterRef<UploadTask>;
+    /** Emitted when a dropped/selected file is rejected due to validation */
+    readonly rejected: _angular_core.OutputEmitterRef<DropZoneRejection[]>;
+    readonly hasTasks: _angular_core.Signal<boolean>;
+    onFilesSelectedOrDropped(rawFiles: File[]): void;
+    onDropZoneRejections(rejections: DropZoneRejection[]): void;
+    onTaskCancel(task: UploadTask): void;
+    onTaskRetry(task: UploadTask): void;
+    onTaskRemove(task: UploadTask): void;
+    private syncTaskState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosPresignedFileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosPresignedFileUploadComponent, "talos-presigned-file-upload", never, { "presignedHandler": { "alias": "presignedHandler"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "minFileSize": { "alias": "minFileSize"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "subTitle": { "alias": "subTitle"; "required": false; "isSignal": true; }; "browseLabel": { "alias": "browseLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "showSummary": { "alias": "showSummary"; "required": false; "isSignal": true; }; "allowCancel": { "alias": "allowCancel"; "required": false; "isSignal": true; }; "allowRetry": { "alias": "allowRetry"; "required": false; "isSignal": true; }; "allowRemove": { "alias": "allowRemove"; "required": false; "isSignal": true; }; "allowCopyUrl": { "alias": "allowCopyUrl"; "required": false; "isSignal": true; }; "metadata": { "alias": "metadata"; "required": false; "isSignal": true; }; "headers": { "alias": "headers"; "required": false; "isSignal": true; }; "tasks": { "alias": "tasks"; "required": false; "isSignal": true; }; }, { "tasks": "tasksChange"; "uploadComplete": "uploadComplete"; "allCompleted": "allCompleted"; "uploadError": "uploadError"; "rejected": "rejected"; }, never, ["[talosUploadActions], [headerExtra]", "[taskExtra], [cardExtra], [itemExtra]", "[taskAction], [taskActions]", "*"], true, never>;
+}
+
+declare class TalosDropZoneModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDropZoneModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosDropZoneModule, never, [typeof TalosDropZoneComponent, typeof TalosFileDropDirective, typeof TalosFileUploadProgressComponent, typeof TalosPresignedFileUploadComponent], [typeof TalosDropZoneComponent, typeof TalosFileDropDirective, typeof TalosFileUploadProgressComponent, typeof TalosPresignedFileUploadComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosDropZoneModule>;
+}
+
+declare class TalosFormFieldComponent implements AfterContentChecked, OnDestroy {
+    private readonly elementRef;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly hint: _angular_core.InputSignal<string>;
+    readonly error: _angular_core.InputSignal<string>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly forId: _angular_core.InputSignal<string>;
+    readonly numberStepper: _angular_core.InputSignal<boolean>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly hasValue: _angular_core.WritableSignal<boolean>;
+    readonly isTextarea: _angular_core.WritableSignal<boolean>;
+    readonly isNumberInput: _angular_core.WritableSignal<boolean>;
+    readonly hasPrefix: _angular_core.WritableSignal<boolean>;
+    readonly hasSuffix: _angular_core.WritableSignal<boolean>;
+    readonly hasSplitStepper: _angular_core.WritableSignal<boolean>;
+    readonly hasStepper: _angular_core.Signal<boolean>;
+    private stepTimer;
+    private stepInterval;
+    private readonly autoId;
+    readonly inputId: _angular_core.Signal<string>;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    ngAfterContentChecked(): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    onInput(): void;
+    onLabelClick(): void;
+    ngOnDestroy(): void;
+    stepNativeInput(isUp: boolean): void;
+    private hasSteppedOnPointer;
+    onStepperClick(event: MouseEvent, isUp: boolean): void;
+    onStepperMouseDown(event: MouseEvent | TouchEvent, isUp: boolean): void;
+    private clearStepTimers;
+    checkValue(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosFormFieldComponent, "talos-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "forId": { "alias": "forId"; "required": false; "isSignal": true; }; "numberStepper": { "alias": "numberStepper"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TalosFormFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosFormFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosFormFieldModule, never, [typeof TalosFormFieldComponent], [typeof TalosFormFieldComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosFormFieldModule>;
+}
+
+type InputSize = 'sm' | 'md' | 'lg';
+declare class TalosInputDirective {
+    /** Sizing variation for input or textarea */
+    readonly size: _angular_core.InputSignal<InputSize>;
+    /** Whether the input is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosInputDirective, "input[talosInput], textarea[talosInput], input[talosTextarea], textarea[talosTextarea], input[talos-input], textarea[talos-textarea]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NumberInputSize = 'sm' | 'md' | 'lg';
+type NumberStepperVariant = 'vertical' | 'split' | 'none';
+interface NumberInputStepEvent {
+    previousValue: number | null;
+    currentValue: number | null;
+    direction: 'up' | 'down';
+}
+
+declare class TalosNumberInputComponent implements ControlValueAccessor, OnDestroy {
+    inputEl?: ElementRef<HTMLInputElement>;
+    private readonly autoId;
+    readonly value: _angular_core.InputSignal<number | null | undefined>;
+    readonly min: _angular_core.InputSignal<number | null>;
+    readonly max: _angular_core.InputSignal<number | null>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly precision: _angular_core.InputSignal<number | null>;
+    readonly size: _angular_core.InputSignal<NumberInputSize>;
+    readonly stepperVariant: _angular_core.InputSignal<NumberStepperVariant>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly stepHold: _angular_core.InputSignal<boolean>;
+    readonly clampValueOnBlur: _angular_core.InputSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly prefixText: _angular_core.InputSignal<string>;
+    readonly suffixText: _angular_core.InputSignal<string>;
+    readonly valueChange: _angular_core.OutputEmitterRef<number | null>;
+    readonly stepUp: _angular_core.OutputEmitterRef<number>;
+    readonly stepDown: _angular_core.OutputEmitterRef<number>;
+    readonly innerValue: _angular_core.WritableSignal<number | null>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    private formDisabled;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    readonly elementId: _angular_core.Signal<string>;
+    readonly isAtMax: _angular_core.Signal<boolean>;
+    readonly isAtMin: _angular_core.Signal<boolean>;
+    private stepTimer;
+    private stepInterval;
+    private onChange;
+    private onTouched;
+    constructor();
+    ngOnDestroy(): void;
+    writeValue(val: number | null): void;
+    registerOnChange(fn: (val: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputChange(event: Event): void;
+    onInputBlur(): void;
+    onInputFocus(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    doStep(isUp: boolean, multiplier?: number): void;
+    private hasSteppedOnPointer;
+    onStepperClick(event: MouseEvent, isUp: boolean): void;
+    onStepperMouseDown(event: MouseEvent | TouchEvent, isUp: boolean): void;
+    private clearStepTimers;
+    private clampAndRound;
+    private roundToPrecision;
+    private updateValue;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosNumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosNumberInputComponent, "talos-number-input, talos-number-field", never, { "value": { "alias": "value"; "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; }; "precision": { "alias": "precision"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "stepperVariant": { "alias": "stepperVariant"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "stepHold": { "alias": "stepHold"; "required": false; "isSignal": true; }; "clampValueOnBlur": { "alias": "clampValueOnBlur"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "prefixText": { "alias": "prefixText"; "required": false; "isSignal": true; }; "suffixText": { "alias": "suffixText"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "stepUp": "stepUp"; "stepDown": "stepDown"; }, never, ["[talosPrefix], [talosTextPrefix], [talosLead], [talosStart], [prefix]", "[talosSuffix], [talosPostfix], [talosTextSuffix], [talosTextPostfix], [talosTrail], [talosEnd], [suffix]"], true, never>;
+}
+
+declare class TalosNumberInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosNumberInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosNumberInputModule, never, [typeof TalosNumberInputComponent], [typeof TalosNumberInputComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosNumberInputModule>;
+}
+
+type OtpInputType = 'number' | 'text' | 'password' | 'alphanumeric';
+type OtpVariant = 'outlined' | 'filled' | 'underlined';
+type OtpSize = 'sm' | 'md' | 'lg';
+type OtpSplitConfig = number | number[] | string | 'none' | boolean;
+interface OtpCompletedEvent {
+    value: string;
+    isComplete: boolean;
+}
+
+declare class TalosOtpComponent implements ControlValueAccessor, AfterViewInit {
+    slotInputs: QueryList<ElementRef<HTMLInputElement>>;
+    /** Total number of OTP digits/slots */
+    readonly length: _angular_core.InputSignal<number>;
+    /** Expected character input type ('number', 'text', 'password', 'alphanumeric') */
+    readonly type: _angular_core.InputSignal<OtpInputType>;
+    /** Visual variant ('outlined' | 'filled' | 'underlined') */
+    readonly variant: _angular_core.InputSignal<OtpVariant>;
+    /** Size scale ('sm' | 'md' | 'lg') */
+    readonly size: _angular_core.InputSignal<OtpSize>;
+    /** Whether to visually mask input characters */
+    readonly mask: _angular_core.InputSignal<boolean>;
+    /** Character to display when masked */
+    readonly maskChar: _angular_core.InputSignal<string>;
+    /** Single placeholder character for empty slots */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Disabled state */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Readonly state */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Error / Invalid state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Automatically focus first slot on init */
+    readonly autoFocus: _angular_core.InputSignal<boolean>;
+    /** Optional separator character between slots or groups (e.g. '-') */
+    readonly separator: _angular_core.InputSignal<string>;
+    /**
+     * Split configuration: number (interval), number[] (group sizes), or string (e.g. '3,3' or '2-2-2')
+     */
+    readonly split: _angular_core.InputSignal<OtpSplitConfig | undefined>;
+    /** Frequency of separator insertion (e.g. 3 for grouping by 3) */
+    readonly separatorInterval: _angular_core.InputSignal<number | undefined>;
+    /** Custom grouping sizes, e.g. [3, 3] or [4, 4] */
+    readonly grouping: _angular_core.InputSignal<OtpSplitConfig | undefined>;
+    /** Whether to allow alphanumeric characters when type is text or alphanumeric */
+    readonly allowAlphanumeric: _angular_core.InputSignal<boolean>;
+    /** Component HTML ID prefix */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Accessible label */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Emitted whenever the combined value changes */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when all slots are filled */
+    readonly completed: _angular_core.OutputEmitterRef<string>;
+    /** Emitted with structured complete state */
+    readonly otpChange: _angular_core.OutputEmitterRef<OtpCompletedEvent>;
+    private readonly defaultId;
+    readonly elementId: _angular_core.Signal<string>;
+    private readonly disabledState;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    /** Slots array for iteration */
+    readonly slotIndices: _angular_core.Signal<number[]>;
+    /** Digit array holding current slot values */
+    readonly digitValues: _angular_core.WritableSignal<string[]>;
+    readonly focusedIndex: _angular_core.WritableSignal<number>;
+    readonly separatorIndices: _angular_core.Signal<Set<number>>;
+    private parseSplit;
+    private onChange;
+    private onTouched;
+    constructor();
+    ngAfterViewInit(): void;
+    /** Gets native input type for slots */
+    getInputType(): string;
+    /** Gets appropriate inputMode for mobile keyboards */
+    getInputMode(): string;
+    /** Value representation for slot */
+    getSlotDisplayValue(index: number): string;
+    onSlotFocus(index: number, event: FocusEvent): void;
+    onSlotBlur(): void;
+    onSlotKeyDown(event: KeyboardEvent, index: number): void;
+    onSlotInput(event: Event, index: number): void;
+    onPaste(event: ClipboardEvent, startIndex: number): void;
+    /** Validates whether a single character is allowed based on input type */
+    private isValidCharacter;
+    /** Focuses the slot input at the specified index */
+    focusSlot(index: number): void;
+    /** Clears all slot values */
+    clear(): void;
+    /** Updates internal state, triggers CVA, and emits change events */
+    private updateValues;
+    writeValue(obj: any): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosOtpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosOtpComponent, "talos-otp, talos-otp-input, talos-pin-input", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "maskChar": { "alias": "maskChar"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "split": { "alias": "split"; "required": false; "isSignal": true; }; "separatorInterval": { "alias": "separatorInterval"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "allowAlphanumeric": { "alias": "allowAlphanumeric"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "completed": "completed"; "otpChange": "otpChange"; }, never, never, true, never>;
+}
+
+declare class TalosOtpModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosOtpModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosOtpModule, never, [typeof TalosOtpComponent], [typeof TalosOtpComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosOtpModule>;
+}
+
+type PasswordStrengthLevel = 'very-weak' | 'weak' | 'fair' | 'good' | 'strong' | 'very-strong';
+type PasswordMeterVariant = 'segmented' | 'continuous';
+type PasswordInputSize = 'sm' | 'md' | 'lg';
+/**
+ * Developer-configurable rule definition for password validation and strength scoring.
+ */
+interface PasswordRule {
+    /** Unique identifier for the rule */
+    id: string;
+    /** Human-readable description displayed in checklists or tooltips */
+    label: string;
+    /** Minimum character length requirement */
+    minLength?: number;
+    /** Regular expression pattern that must match */
+    pattern?: RegExp;
+    /** Custom validator function returning true when criteria is met */
+    validator?: (password: string) => boolean;
+    /** Optional weight or scoring contribution for this rule (default: 1) */
+    weight?: number;
+    /** Optional hint or helper text explaining this rule */
+    hint?: string;
+}
+/**
+ * Status of an individual evaluated rule.
+ */
+interface PasswordRuleStatus {
+    /** The rule evaluated */
+    rule: PasswordRule;
+    /** Whether the rule requirement was satisfied */
+    passed: boolean;
+}
+/**
+ * Result of a password strength evaluation.
+ */
+interface PasswordStrengthResult {
+    /** Overall score as a percentage (0 - 100) */
+    score: number;
+    /** Strength classification level */
+    level: PasswordStrengthLevel;
+    /** Localized or custom display label for the strength level */
+    levelLabel: string;
+    /** Number of rules satisfied */
+    passedCount: number;
+    /** Total number of evaluated rules */
+    totalRules: number;
+    /** Detailed list of each rule and its pass/fail state */
+    rules: PasswordRuleStatus[];
+    /** Whether all rules (or required criteria) are satisfied */
+    isValid: boolean;
+}
+/**
+ * Default rule set provided out-of-the-box.
+ */
+declare const DEFAULT_PASSWORD_RULES: PasswordRule[];
+declare const DEFAULT_STRENGTH_LABELS: Record<PasswordStrengthLevel, string>;
+
+declare class TalosPasswordInputComponent implements ControlValueAccessor {
+    inputElementRef?: ElementRef<HTMLInputElement>;
+    private readonly autoId;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<PasswordInputSize>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly autocomplete: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly showPrefixIcon: _angular_core.InputSignal<boolean>;
+    readonly allowToggleMask: _angular_core.InputSignal<boolean>;
+    readonly masked: _angular_core.InputSignal<boolean>;
+    readonly maskToggleAriaLabel: _angular_core.InputSignal<string>;
+    readonly showStrengthMeter: _angular_core.InputSignal<boolean>;
+    readonly meterVariant: _angular_core.InputSignal<PasswordMeterVariant>;
+    readonly showStrengthLabel: _angular_core.InputSignal<boolean>;
+    readonly showRuleList: _angular_core.InputSignal<boolean>;
+    readonly rules: _angular_core.InputSignalWithTransform<PasswordRule[] | undefined, PasswordRule[] | undefined>;
+    readonly strengthLabels: _angular_core.InputSignalWithTransform<Record<PasswordStrengthLevel, string> | undefined, Record<PasswordStrengthLevel, string> | undefined>;
+    readonly strengthCalculator: _angular_core.InputSignal<((password: string, rules: PasswordRule[]) => PasswordStrengthResult) | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    readonly maskChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly strengthChange: _angular_core.OutputEmitterRef<PasswordStrengthResult>;
+    readonly inputFocus: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly inputBlur: _angular_core.OutputEmitterRef<FocusEvent>;
+    protected readonly innerValue: _angular_core.WritableSignal<string>;
+    protected readonly isMasked: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly formDisabled: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    readonly elementId: _angular_core.Signal<string>;
+    readonly strengthMeterId: _angular_core.Signal<string>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    readonly strengthResult: _angular_core.Signal<PasswordStrengthResult>;
+    /** Number of active segments for the 4-segment or 5-segment meter */
+    readonly activeSegmentCount: _angular_core.Signal<number>;
+    constructor();
+    toggleMask(): void;
+    protected onInput(event: Event): void;
+    protected onFocus(event: FocusEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    /** Focus the input programmatically */
+    focus(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private calculateStrength;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosPasswordInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosPasswordInputComponent, "talos-password-input, talos-password-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "showPrefixIcon": { "alias": "showPrefixIcon"; "required": false; "isSignal": true; }; "allowToggleMask": { "alias": "allowToggleMask"; "required": false; "isSignal": true; }; "masked": { "alias": "masked"; "required": false; "isSignal": true; }; "maskToggleAriaLabel": { "alias": "maskToggleAriaLabel"; "required": false; "isSignal": true; }; "showStrengthMeter": { "alias": "showStrengthMeter"; "required": false; "isSignal": true; }; "meterVariant": { "alias": "meterVariant"; "required": false; "isSignal": true; }; "showStrengthLabel": { "alias": "showStrengthLabel"; "required": false; "isSignal": true; }; "showRuleList": { "alias": "showRuleList"; "required": false; "isSignal": true; }; "rules": { "alias": "rules"; "required": false; "isSignal": true; }; "strengthLabels": { "alias": "strengthLabels"; "required": false; "isSignal": true; }; "strengthCalculator": { "alias": "strengthCalculator"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "maskChange": "maskChange"; "strengthChange": "strengthChange"; "inputFocus": "inputFocus"; "inputBlur": "inputBlur"; }, never, ["[prefix], [talosPrefix], [talosTextPrefix]", "[suffix], [talosSuffix], [talosPostfix], [talosTextSuffix], [talosTextPostfix]"], true, never>;
+}
+
+declare class TalosPasswordInputDirective {
+    private readonly elementRef;
+    /** Sizing variation for the input */
+    readonly size: _angular_core.InputSignal<PasswordInputSize>;
+    /** Whether the input is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the password characters are masked */
+    readonly masked: _angular_core.InputSignal<boolean>;
+    /** Emitted when masked state changes */
+    readonly maskChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Internal toggle method */
+    toggleMask(): void;
+    /** Focus the underlying input element */
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosPasswordInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosPasswordInputDirective, "input[talosPasswordInput], input[talosPassword], input[talos-password-input]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "masked": { "alias": "masked"; "required": false; "isSignal": true; }; }, { "maskChange": "maskChange"; }, never, never, true, never>;
+}
+
+declare class TalosPasswordInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosPasswordInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosPasswordInputModule, never, [typeof TalosPasswordInputComponent, typeof TalosPasswordInputDirective], [typeof TalosPasswordInputComponent, typeof TalosPasswordInputDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosPasswordInputModule>;
+}
+
+type RadioSize = 'sm' | 'md' | 'lg';
+type RadioVariant = 'primary' | 'secondary' | 'success' | 'danger';
+declare class TalosRadioDirective {
+    /** Sizing variation for the radio button */
+    readonly size: _angular_core.InputSignal<RadioSize>;
+    /** Visual color variant for the radio button */
+    readonly variant: _angular_core.InputSignal<RadioVariant>;
+    /** Whether the radio button is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRadioDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosRadioDirective, "input[type=\"radio\"][talosRadio], input[type=\"radio\"][talos-radio]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TalosRadioComponent {
+    private readonly radioGroup;
+    private readonly cdr;
+    radioInputEl?: ElementRef<HTMLInputElement>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<RadioSize | undefined>;
+    readonly variant: _angular_core.InputSignal<RadioVariant | undefined>;
+    readonly id: _angular_core.InputSignal<string>;
+    private readonly defaultId;
+    readonly elementId: _angular_core.Signal<string>;
+    readonly effectiveName: _angular_core.Signal<string>;
+    readonly effectiveSize: _angular_core.Signal<RadioSize>;
+    readonly effectiveVariant: _angular_core.Signal<RadioVariant>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly checked: _angular_core.Signal<boolean>;
+    onRadioChange(event: Event): void;
+    focusInput(): void;
+    markForCheck(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosRadioComponent, "talos-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type RadioDirection = 'vertical' | 'horizontal';
+declare class TalosRadioGroupComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<RadioSize>;
+    readonly variant: _angular_core.InputSignal<RadioVariant>;
+    readonly direction: _angular_core.InputSignal<RadioDirection>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<unknown>;
+    readonly radios: _angular_core.Signal<readonly TalosRadioComponent[]>;
+    readonly value: _angular_core.WritableSignal<unknown>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    selectValue(val: unknown): void;
+    markAsTouched(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosRadioGroupComponent, "talos-radio-group", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, ["radios"], ["*"], true, never>;
+}
+
+/**
+ * Convenience NgModule wrapping the standalone radio components and directive.
+ *
+ * Allows developers who prefer `TalosRadioModule` to import it into standalone components
+ * or legacy NgModule-based applications.
+ */
+declare class TalosRadioModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRadioModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosRadioModule, never, [typeof TalosRadioDirective, typeof TalosRadioGroupComponent, typeof TalosRadioComponent], [typeof TalosRadioDirective, typeof TalosRadioGroupComponent, typeof TalosRadioComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosRadioModule>;
+}
+
+type RangeInputSize = 'sm' | 'md' | 'lg';
+type RangeInputVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'info';
+type RangeInputValue = number | [number, number];
+type RangeInputTooltipMode = 'always' | 'hover' | 'drag' | 'none';
+interface RangeInputMark {
+    value: number;
+    label?: string;
+    tooltip?: string;
+}
+interface RangeInputTick {
+    value: number;
+    percent: number;
+    label?: string;
+    tooltip?: string;
+    active: boolean;
+}
+interface RangeInputChangeEvent {
+    value: RangeInputValue;
+    source: 'drag' | 'keyboard' | 'input' | 'track-click';
+}
+
+declare class TalosRangeInputDirective {
+    private readonly elementRef;
+    /** Size variant */
+    readonly size: _angular_core.InputSignal<RangeInputSize>;
+    /** Visual color variant */
+    readonly variant: _angular_core.InputSignal<RangeInputVariant>;
+    /** Error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    protected readonly fillPercentStyle: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRangeInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosRangeInputDirective, "input[type=\"range\"][talosRangeInput], input[type=\"range\"][talos-range-input]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TalosRangeInputComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    private readonly trackContainerRef;
+    private readonly thumb0Ref;
+    private readonly thumb1Ref;
+    /** Minimum allowed value */
+    readonly min: _angular_core.InputSignal<number>;
+    /** Maximum allowed value */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Step increment for values */
+    readonly step: _angular_core.InputSignal<number>;
+    /** Step interval for tick marks / labels generation (e.g. 10, 20, 25) */
+    readonly interval: _angular_core.InputSignal<number | null>;
+    /** Whether the slider operates in dual-thumb range mode */
+    readonly range: _angular_core.InputSignal<boolean>;
+    /** Minimum distance between handles in dual mode */
+    readonly minRange: _angular_core.InputSignal<number>;
+    /** Maximum distance between handles in dual mode */
+    readonly maxRange: _angular_core.InputSignal<number | null>;
+    /** Discrete tick marks with optional custom labels */
+    readonly marks: _angular_core.InputSignal<number[] | RangeInputMark[] | null>;
+    /** Whether to show tick mark notches on the track */
+    readonly showTicks: _angular_core.InputSignal<boolean>;
+    /** Whether to show interval/tick labels under the track */
+    readonly showIntervals: _angular_core.InputSignal<boolean>;
+    /** Alias for showIntervals */
+    readonly showLabels: _angular_core.InputSignal<boolean>;
+    /** Whether to snap slider thumb only to configured tick marks */
+    readonly snapToTicks: _angular_core.InputSignal<boolean>;
+    /** Sizing variant */
+    readonly size: _angular_core.InputSignal<RangeInputSize>;
+    /** Visual color variant */
+    readonly variant: _angular_core.InputSignal<RangeInputVariant>;
+    /** Disabled state */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Read-only state */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Top label text */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Floating label mode toggle */
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    /** Helper hint text */
+    readonly hint: _angular_core.InputSignal<string>;
+    /** Whether to render synchronized number inputs */
+    readonly showInputs: _angular_core.InputSignal<boolean>;
+    /** Whether to show top value badge when inputs are disabled */
+    readonly showValueBadge: _angular_core.InputSignal<boolean>;
+    /** Tooltip display mode ('always' | 'hover' | 'drag' | 'none') */
+    readonly showTooltip: _angular_core.InputSignal<RangeInputTooltipMode>;
+    /** Optional prefix string (e.g. '$') */
+    readonly prefix: _angular_core.InputSignal<string>;
+    /** Optional suffix string (e.g. '%', '°C') */
+    readonly suffix: _angular_core.InputSignal<string>;
+    /** Custom value formatter function */
+    readonly formatter: _angular_core.InputSignal<((value: number) => string) | null>;
+    /** Accessibility label for single slider */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Accessibility label for start thumb in range mode */
+    readonly ariaLabelStart: _angular_core.InputSignal<string>;
+    /** Accessibility label for end thumb in range mode */
+    readonly ariaLabelEnd: _angular_core.InputSignal<string>;
+    /** Element unique ID */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Standalone value input binding */
+    readonly value: _angular_core.InputSignal<RangeInputValue | null>;
+    /** Emitted when value changes */
+    readonly valueChange: _angular_core.OutputEmitterRef<RangeInputValue>;
+    /** Emitted during active dragging or keyboard movement */
+    readonly inputChange: _angular_core.OutputEmitterRef<RangeInputChangeEvent>;
+    /** Emitted on drag end, click release or input commit */
+    readonly change: _angular_core.OutputEmitterRef<RangeInputChangeEvent>;
+    private readonly defaultId;
+    readonly elementId: _angular_core.Signal<string>;
+    readonly internalValue: _angular_core.WritableSignal<RangeInputValue | null>;
+    readonly isCvaDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly focusedThumb: _angular_core.WritableSignal<number | null>;
+    readonly hoveredThumb: _angular_core.WritableSignal<number | null>;
+    readonly draggingThumb: _angular_core.WritableSignal<number | null>;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    /** Determines whether the component is in dual-handle range mode */
+    readonly isDualRange: _angular_core.Signal<boolean>;
+    /** Resolved start value (single value or lower bound of range) */
+    readonly startValue: _angular_core.Signal<number>;
+    /** Resolved end value (upper bound of range mode) */
+    readonly endValue: _angular_core.Signal<number>;
+    /** Overall span */
+    readonly span: _angular_core.Signal<number>;
+    /** Percentage position of thumb 0 */
+    readonly thumb0Percent: _angular_core.Signal<number>;
+    /** Percentage position of thumb 1 */
+    readonly thumb1Percent: _angular_core.Signal<number>;
+    /** Fill bar left percentage */
+    readonly fillLeftPercent: _angular_core.Signal<number>;
+    /** Fill bar width percentage */
+    readonly fillWidthPercent: _angular_core.Signal<number>;
+    /** Computed list of tick marks */
+    readonly ticks: _angular_core.Signal<RangeInputTick[]>;
+    /** Computed list of interval/tick labels */
+    readonly labels: _angular_core.Signal<RangeInputTick[]>;
+    readonly isDragging: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(val: RangeInputValue | null): void;
+    registerOnChange(fn: (val: RangeInputValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private clamp;
+    private valueToPercent;
+    private percentToValue;
+    private snapValue;
+    formatDisplayValue(val: number): string;
+    isTooltipVisible(thumbIndex: number): boolean;
+    private emitUpdate;
+    private markAsTouched;
+    onThumbFocus(thumbIndex: number): void;
+    onThumbBlur(thumbIndex: number): void;
+    onThumbMouseEnter(thumbIndex: number): void;
+    onThumbMouseLeave(thumbIndex: number): void;
+    onThumbPointerDown(thumbIndex: number, event: PointerEvent): void;
+    onTrackPointerDown(event: PointerEvent): void;
+    private updateValueFromPointer;
+    onThumbKeyDown(thumbIndex: number, event: KeyboardEvent): void;
+    onNumberInputChange(thumbIndex: number, event: Event): void;
+    onTickClick(tick: RangeInputTick, event: MouseEvent): void;
+    onLabelClick(tick: RangeInputTick, event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRangeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosRangeInputComponent, "talos-range-input, talos-range-slider, talos-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "minRange": { "alias": "minRange"; "required": false; "isSignal": true; }; "maxRange": { "alias": "maxRange"; "required": false; "isSignal": true; }; "marks": { "alias": "marks"; "required": false; "isSignal": true; }; "showTicks": { "alias": "showTicks"; "required": false; "isSignal": true; }; "showIntervals": { "alias": "showIntervals"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; "snapToTicks": { "alias": "snapToTicks"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "showInputs": { "alias": "showInputs"; "required": false; "isSignal": true; }; "showValueBadge": { "alias": "showValueBadge"; "required": false; "isSignal": true; }; "showTooltip": { "alias": "showTooltip"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "formatter": { "alias": "formatter"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelStart": { "alias": "ariaLabelStart"; "required": false; "isSignal": true; }; "ariaLabelEnd": { "alias": "ariaLabelEnd"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "inputChange": "inputChange"; "change": "change"; }, never, never, true, never>;
+}
+
+declare class TalosRangeInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRangeInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosRangeInputModule, never, [typeof TalosRangeInputComponent, typeof TalosRangeInputDirective], [typeof TalosRangeInputComponent, typeof TalosRangeInputDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosRangeInputModule>;
+}
+
+type RatingSize = 'sm' | 'md' | 'lg' | 'xl';
+type RatingVariant = 'warning' | 'primary' | 'danger' | 'success' | 'purple' | 'custom';
+type RatingLabelPosition = 'right' | 'bottom';
+type RatingAnimationMode = 'none' | 'subtle' | 'pop' | 'particles' | 'full';
+interface RatingHoverEvent {
+    value: number;
+    index: number;
+}
+interface RatingChangeEvent {
+    value: number;
+    oldValue: number;
+}
+
+declare class TalosRatingComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    private animationTimeout;
+    /** Current numerical rating value */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Maximum rating count / total stars (default: 5) */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Whether clicking the current value resets/clears to 0 (default: true) */
+    readonly allowClear: _angular_core.InputSignal<boolean>;
+    /** Read-only display mode */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Disabled state */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Sizing scale ('sm' | 'md' | 'lg' | 'xl') */
+    readonly size: _angular_core.InputSignal<RatingSize>;
+    /** Visual color variant ('warning' | 'primary' | 'danger' | 'success' | 'purple' | 'custom') */
+    readonly variant: _angular_core.InputSignal<RatingVariant>;
+    /** Custom HEX or CSS color code when variant is 'custom' or overriding */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Animation mode ('none' | 'subtle' | 'pop' | 'particles' | 'full') */
+    readonly animation: _angular_core.InputSignal<RatingAnimationMode>;
+    /** Whether animations are enabled (default: true) */
+    readonly animated: _angular_core.InputSignal<boolean>;
+    /** Tooltip/label strings for each star index (1-based) */
+    readonly tooltips: _angular_core.InputSignal<string[]>;
+    /** Whether to show numeric score badge */
+    readonly showScore: _angular_core.InputSignal<boolean>;
+    /** Whether to show text label from tooltips or current state */
+    readonly showLabel: _angular_core.InputSignal<boolean>;
+    /** Position of score/tooltip label */
+    readonly labelPosition: _angular_core.InputSignal<RatingLabelPosition>;
+    /** Component HTML ID */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Accessibility label */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Emitted when value changes */
+    readonly valueChange: _angular_core.OutputEmitterRef<number>;
+    /** Emitted with old and new values */
+    readonly rateChange: _angular_core.OutputEmitterRef<RatingChangeEvent>;
+    /** Emitted when hovering over rating items */
+    readonly hoverChange: _angular_core.OutputEmitterRef<RatingHoverEvent>;
+    /** Emitted when rating is cleared */
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    private readonly defaultId;
+    readonly elementId: _angular_core.Signal<string>;
+    readonly internalValue: _angular_core.WritableSignal<number>;
+    readonly hoverValue: _angular_core.WritableSignal<number | null>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    /** Index of currently pop-animating star */
+    readonly animatingIndex: _angular_core.WritableSignal<number | null>;
+    /** Index of currently particle-bursting star */
+    readonly activeBurstIndex: _angular_core.WritableSignal<number | null>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveReadonly: _angular_core.Signal<boolean>;
+    readonly effectiveAnimation: _angular_core.Signal<RatingAnimationMode>;
+    readonly showParticles: _angular_core.Signal<boolean>;
+    readonly showPop: _angular_core.Signal<boolean>;
+    readonly currentValue: _angular_core.Signal<number>;
+    readonly displayValue: _angular_core.Signal<number>;
+    /** Array of star item indices [1, 2, ..., max] */
+    readonly items: _angular_core.Signal<number[]>;
+    /** Active tooltip text based on current display value */
+    readonly activeTooltip: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    writeValue(val: number): void;
+    registerOnChange(fn: (val: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onItemMouseEnter(index: number): void;
+    onItemClick(index: number): void;
+    onMouseLeave(): void;
+    private triggerClickEffects;
+    onKeyDown(event: KeyboardEvent): void;
+    onFocus(): void;
+    onBlur(): void;
+    private setValue;
+    private markAsTouched;
+    isItemActive(index: number): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRatingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosRatingComponent, "talos-rating, talos-rate", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "allowClear": { "alias": "allowClear"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "tooltips": { "alias": "tooltips"; "required": false; "isSignal": true; }; "showScore": { "alias": "showScore"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "rateChange": "rateChange"; "hoverChange": "hoverChange"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+declare class TalosRatingModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosRatingModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosRatingModule, never, [typeof TalosRatingComponent], [typeof TalosRatingComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosRatingModule>;
+}
+
+declare class OptionComponent {
+    private readonly elementRef;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly selected: _angular_core.OutputEmitterRef<OptionComponent>;
+    readonly isSelected: _angular_core.WritableSignal<boolean>;
+    readonly isActive: _angular_core.WritableSignal<boolean>;
+    readonly hidden: _angular_core.WritableSignal<boolean>;
+    displayText(): string;
+    onClick(event: MouseEvent): void;
+    scrollIntoViewIfNeeded(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OptionComponent, "talos-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, ["*"], true, never>;
+}
+
+declare class OptionGroupComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly options: _angular_core.Signal<readonly OptionComponent[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OptionGroupComponent, "talos-option-group", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["options"], ["talos-option, app-option"], true, never>;
+}
+
+declare class SelectInputComponent implements ControlValueAccessor, AfterContentChecked {
+    private readonly elementRef;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly placement: _angular_core.InputSignal<"bottom" | "top" | "auto">;
+    readonly selectionChange: _angular_core.OutputEmitterRef<unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly searchChange: _angular_core.OutputEmitterRef<string>;
+    readonly options: _angular_core.Signal<readonly OptionComponent[]>;
+    readonly optionGroups: _angular_core.Signal<readonly OptionGroupComponent[]>;
+    searchInputEl?: ElementRef<HTMLInputElement>;
+    triggerEl?: ElementRef<HTMLDivElement>;
+    readonly componentId: string;
+    readonly listboxId: string;
+    readonly value: _angular_core.WritableSignal<unknown>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly searchValue: _angular_core.WritableSignal<string>;
+    readonly focusedIndex: _angular_core.WritableSignal<number>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly hasPrefix: _angular_core.WritableSignal<boolean>;
+    readonly hasSuffix: _angular_core.WritableSignal<boolean>;
+    readonly effectivePlacement: _angular_core.WritableSignal<"bottom" | "top">;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly selectedOption: _angular_core.Signal<OptionComponent | null>;
+    readonly displayLabel: _angular_core.Signal<string>;
+    readonly visibleOptions: _angular_core.Signal<OptionComponent[]>;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggleOpen(): void;
+    open(): void;
+    close(): void;
+    selectOption(option: OptionComponent | null): void;
+    onClear(event: MouseEvent): void;
+    markAsTouched(): void;
+    onSearchInput(event: Event): void;
+    clearSearch(): void;
+    private filterOptions;
+    onKeyDown(event: KeyboardEvent): void;
+    ngAfterContentChecked(): void;
+    private checkAffixes;
+    private calculateAutoPlacement;
+    onDocumentClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectInputComponent, "talos-select-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "opened": "opened"; "closed": "closed"; "searchChange": "searchChange"; }, ["options", "optionGroups"], ["[prefix], [talosPrefix], [talosTextPrefix], [talosLead], [talosStart]", "[suffix], [talosSuffix], [talosPostfix], [talosTextSuffix], [talosTextPostfix], [talosTrail], [talosEnd]", "*"], true, never>;
+}
+
+interface CascadeOption {
+    value: unknown;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    leaf?: boolean;
+    children?: CascadeOption[];
+    [key: string]: unknown;
+}
+type CascadeExpandTrigger = 'click' | 'hover';
+type CascadeValueMode = 'path' | 'leaf';
+interface CascadeSearchMatch {
+    option: CascadeOption;
+    path: CascadeOption[];
+    labelPath: string;
+    valuePath: unknown[];
+    disabled: boolean;
+}
+
+interface ColumnData {
+    depth: number;
+    options: CascadeOption[];
+    selectedOption: CascadeOption | null;
+}
+declare class CascadeSelectComponent implements ControlValueAccessor, AfterContentChecked {
+    private readonly elementRef;
+    readonly options: _angular_core.InputSignal<CascadeOption[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly floatingLabel: _angular_core.InputSignal<boolean>;
+    readonly floating: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly expandTrigger: _angular_core.InputSignal<CascadeExpandTrigger>;
+    readonly valueMode: _angular_core.InputSignal<CascadeValueMode>;
+    readonly separator: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly pathChange: _angular_core.OutputEmitterRef<CascadeOption[]>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly activePath: _angular_core.WritableSignal<CascadeOption[]>;
+    readonly selectedPath: _angular_core.WritableSignal<CascadeOption[]>;
+    readonly searchTerm: _angular_core.WritableSignal<string>;
+    readonly highlightedSearchIndex: _angular_core.WritableSignal<number>;
+    readonly hasPrefix: _angular_core.WritableSignal<boolean>;
+    readonly hasSuffix: _angular_core.WritableSignal<boolean>;
+    readonly hasError: _angular_core.WritableSignal<boolean>;
+    searchInputEl?: ElementRef<HTMLInputElement>;
+    triggerBoxEl?: ElementRef<HTMLElement>;
+    private onChange;
+    private onTouched;
+    readonly isFloatingMode: _angular_core.Signal<boolean>;
+    readonly displayLabel: _angular_core.Signal<string>;
+    readonly isFloated: _angular_core.Signal<boolean>;
+    readonly activeColumns: _angular_core.Signal<ColumnData[]>;
+    readonly allSearchablePaths: _angular_core.Signal<CascadeSearchMatch[]>;
+    readonly filteredSearchResults: _angular_core.Signal<CascadeSearchMatch[]>;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    toggleDropdown(): void;
+    openDropdown(): void;
+    closeDropdown(): void;
+    onDocumentClick(event: MouseEvent): void;
+    hasChildren(option: CascadeOption): boolean;
+    isOptionSelected(depth: number, option: CascadeOption): boolean;
+    isOptionActiveBranch(depth: number, option: CascadeOption): boolean;
+    onOptionHover(depth: number, option: CascadeOption): void;
+    onOptionClick(depth: number, option: CascadeOption): void;
+    private expandOption;
+    commitSelection(path: CascadeOption[]): void;
+    onClear(event: MouseEvent): void;
+    onSearchInput(event: Event): void;
+    clearSearch(): void;
+    selectSearchResult(match: CascadeSearchMatch): void;
+    onSearchKeyDown(event: KeyboardEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private findPathForValue;
+    ngAfterContentChecked(): void;
+    private checkAffixes;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CascadeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CascadeSelectComponent, "talos-cascade-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "floating": { "alias": "floating"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "expandTrigger": { "alias": "expandTrigger"; "required": false; "isSignal": true; }; "valueMode": { "alias": "valueMode"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "pathChange": "pathChange"; "selectionChange": "selectionChange"; "opened": "opened"; "closed": "closed"; }, never, ["[prefix], [talosPrefix], [talosTextPrefix], [talosLead], [talosStart]", "[suffix], [talosSuffix], [talosPostfix], [talosTextSuffix], [talosTextPostfix], [talosTrail], [talosEnd]"], true, never>;
+}
+
+/**
+ * Convenience NgModule wrapping the standalone select input, option, and cascade select components.
+ *
+ * Allows developers who prefer `SelectInputModule` to import it into standalone components
+ * or legacy NgModule-based applications.
+ */
+declare class SelectInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SelectInputModule, never, [typeof SelectInputComponent, typeof OptionComponent, typeof OptionGroupComponent, typeof CascadeSelectComponent], [typeof SelectInputComponent, typeof OptionComponent, typeof OptionGroupComponent, typeof CascadeSelectComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SelectInputModule>;
+}
+
+type SlideToggleSize = 'sm' | 'md' | 'lg';
+type SlideToggleVariant = 'primary' | 'secondary' | 'success' | 'danger';
+declare class TalosSlideToggleDirective {
+    private readonly elementRef;
+    /** Standalone checked state */
+    readonly checked: _angular_core.InputSignal<boolean>;
+    /** Sizing variation for the slide toggle */
+    readonly size: _angular_core.InputSignal<SlideToggleSize>;
+    /** Visual color variant for the slide toggle */
+    readonly variant: _angular_core.InputSignal<SlideToggleVariant>;
+    /** Whether the slide toggle is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the slide toggle is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Output event emitted when checked state changes */
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    onNativeChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSlideToggleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosSlideToggleDirective, "input[type=\"checkbox\"][talosSlideToggle], input[type=\"checkbox\"][talos-slide-toggle], input[type=\"checkbox\"][talosSwitch], input[type=\"checkbox\"][talos-switch]", ["talosSlideToggle"], { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+}
+
+type SlideToggleLabelPosition = 'before' | 'after';
+declare class TalosSlideToggleComponent implements ControlValueAccessor {
+    private readonly inputRef;
+    /** Standalone checked state input */
+    readonly checked: _angular_core.InputSignal<boolean>;
+    /** Sizing variation for the toggle switch */
+    readonly size: _angular_core.InputSignal<SlideToggleSize>;
+    /** Visual color variant for the toggle switch */
+    readonly variant: _angular_core.InputSignal<SlideToggleVariant>;
+    /** Whether the toggle switch is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the toggle switch is in an invalid error state */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Position of the label text relative to the toggle switch */
+    readonly labelPosition: _angular_core.InputSignal<SlideToggleLabelPosition>;
+    /** Optional label text fallback if not projecting content */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Element HTML ID */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Emitted when checked state changes */
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly defaultId;
+    readonly elementId: _angular_core.Signal<string>;
+    readonly internalValue: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isTouched: _angular_core.WritableSignal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    readonly isChecked: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(val: boolean): void;
+    registerOnChange(fn: (val: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onDirectiveCheckedChange(isChecked: boolean): void;
+    markAsTouched(): void;
+    /** Focuses the native HTML input element */
+    focusInput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSlideToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosSlideToggleComponent, "talos-slide-toggle, talos-switch", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Convenience NgModule wrapping standalone slide-toggle directive and component.
+ */
+declare class TalosSlideToggleModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSlideToggleModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosSlideToggleModule, never, [typeof TalosSlideToggleDirective, typeof TalosSlideToggleComponent], [typeof TalosSlideToggleDirective, typeof TalosSlideToggleComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosSlideToggleModule>;
+}
+
+type TransferListSize = 'sm' | 'md' | 'lg';
+type TransferListVariant = 'outlined' | 'elevated' | 'flat' | 'bordered';
+type TransferListSearchMode = 'client' | 'server';
+type TransferListDragMode = 'handle' | 'card' | 'item';
+type TransferListDirection = 'toTarget' | 'toSource';
+type TransferListPane = 'source' | 'target';
+interface TalosTransferItem {
+    id?: string | number;
+    key?: string | number;
+    value?: string | number;
+    label?: string;
+    title?: string;
+    name?: string;
+    description?: string;
+    disabled?: boolean;
+    icon?: string;
+    avatar?: string;
+    badge?: string;
+    tag?: string;
+    [key: string]: unknown;
+}
+interface TalosTransferEvent<T = unknown> {
+    source: T[];
+    target: T[];
+    moved: T[];
+    direction: TransferListDirection;
+}
+interface TalosTransferSelectionChange<T = unknown> {
+    sourceSelected: T[];
+    targetSelected: T[];
+    sourceSelectedKeys: (string | number)[];
+    targetSelectedKeys: (string | number)[];
+}
+interface TalosTransferListItemContext<T = unknown> {
+    $implicit: T;
+    item: T;
+    pane: TransferListPane;
+    selected: boolean;
+    disabled: boolean;
+    index: number;
+}
+type TransferListFilterFn<T = unknown> = (item: T, query: string, pane: TransferListPane) => boolean;
+type TransferListSearchHandler<T = unknown> = (query: string, pane: TransferListPane) => Observable<T[]> | Promise<T[]> | T[];
+interface TransferListSearchQueryEvent {
+    query: string;
+    pane: TransferListPane;
+}
+interface TransferListSearchErrorEvent {
+    error: unknown;
+    query: string;
+    pane: TransferListPane;
+}
+type TransferListItemKeyFn<T = unknown> = (item: T) => string | number;
+type TransferListItemLabelFn<T = unknown> = (item: T) => string;
+type TransferListItemDescriptionFn<T = unknown> = (item: T) => string;
+type TransferListItemDisabledFn<T = unknown> = (item: T) => boolean;
+
+declare class TalosTransferListComponent<T = unknown> implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly source: _angular_core.InputSignal<readonly T[] | T[]>;
+    readonly target: _angular_core.InputSignal<readonly T[] | T[]>;
+    readonly titles: _angular_core.InputSignal<[string, string]>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly searchMode: _angular_core.InputSignal<TransferListSearchMode>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string | [string, string]>;
+    readonly sourceSearchQuery: _angular_core.InputSignal<string>;
+    readonly targetSearchQuery: _angular_core.InputSignal<string>;
+    readonly searchDebounce: _angular_core.InputSignal<number>;
+    readonly searchHandler: _angular_core.InputSignal<TransferListSearchHandler<T> | null>;
+    readonly sourceSearchHandler: _angular_core.InputSignal<((query: string) => Observable<T[]> | Promise<T[]> | T[]) | null>;
+    readonly targetSearchHandler: _angular_core.InputSignal<((query: string) => Observable<T[]> | Promise<T[]> | T[]) | null>;
+    readonly sourceLoading: _angular_core.InputSignal<boolean>;
+    readonly targetLoading: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly showSelectAll: _angular_core.InputSignal<boolean>;
+    readonly showMoveAll: _angular_core.InputSignal<boolean>;
+    readonly showReorder: _angular_core.InputSignal<boolean>;
+    readonly dragDrop: _angular_core.InputSignal<boolean>;
+    readonly dragMode: _angular_core.InputSignal<TransferListDragMode>;
+    readonly dragHandle: _angular_core.InputSignal<boolean | null>;
+    readonly size: _angular_core.InputSignal<TransferListSize>;
+    readonly variant: _angular_core.InputSignal<TransferListVariant>;
+    readonly height: _angular_core.InputSignal<string | number | null>;
+    readonly listWidth: _angular_core.InputSignal<string | number | null>;
+    readonly itemKey: _angular_core.InputSignal<TransferListItemKeyFn<T> | keyof T | null>;
+    readonly itemLabel: _angular_core.InputSignal<keyof T | TransferListItemLabelFn<T> | null>;
+    readonly itemDescription: _angular_core.InputSignal<keyof T | TransferListItemDescriptionFn<T> | null>;
+    readonly itemDisabled: _angular_core.InputSignal<keyof T | TransferListItemDisabledFn<T> | null>;
+    readonly filterFn: _angular_core.InputSignal<TransferListFilterFn<T> | null>;
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<TalosTransferListItemContext<T>> | null>;
+    readonly emptySourceText: _angular_core.InputSignal<string>;
+    readonly emptyTargetText: _angular_core.InputSignal<string>;
+    readonly searchingText: _angular_core.InputSignal<string>;
+    readonly noMatchesText: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly isSourceSearching: _angular_core.Signal<boolean>;
+    readonly isTargetSearching: _angular_core.Signal<boolean>;
+    readonly useDragHandle: _angular_core.Signal<boolean>;
+    readonly sourceChange: _angular_core.OutputEmitterRef<T[]>;
+    readonly targetChange: _angular_core.OutputEmitterRef<T[]>;
+    readonly transfer: _angular_core.OutputEmitterRef<TalosTransferEvent<T>>;
+    readonly search: _angular_core.OutputEmitterRef<TransferListSearchQueryEvent>;
+    readonly sourceSearchChange: _angular_core.OutputEmitterRef<string>;
+    readonly targetSearchChange: _angular_core.OutputEmitterRef<string>;
+    readonly searchError: _angular_core.OutputEmitterRef<TransferListSearchErrorEvent>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<TalosTransferSelectionChange<T>>;
+    readonly targetReorder: _angular_core.OutputEmitterRef<T[]>;
+    private readonly autoId;
+    readonly componentId: _angular_core.Signal<string>;
+    private readonly formDisabled;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly internalSource: _angular_core.WritableSignal<T[]>;
+    readonly internalTarget: _angular_core.WritableSignal<T[]>;
+    readonly sourceSelectedKeys: _angular_core.WritableSignal<Set<string | number>>;
+    readonly targetSelectedKeys: _angular_core.WritableSignal<Set<string | number>>;
+    readonly internalSourceQuery: _angular_core.WritableSignal<string>;
+    readonly internalTargetQuery: _angular_core.WritableSignal<string>;
+    readonly internalSourceLoading: _angular_core.WritableSignal<boolean>;
+    readonly internalTargetLoading: _angular_core.WritableSignal<boolean>;
+    readonly effectiveSourceLoading: _angular_core.Signal<boolean>;
+    readonly effectiveTargetLoading: _angular_core.Signal<boolean>;
+    private readonly sourceSearchSubject$;
+    private readonly targetSearchSubject$;
+    private readonly destroyRef;
+    private onChange;
+    private onTouched;
+    constructor();
+    readonly sourcePlaceholder: _angular_core.Signal<string>;
+    readonly targetPlaceholder: _angular_core.Signal<string>;
+    readonly containerHeight: _angular_core.Signal<string>;
+    readonly effectivePaneWidth: _angular_core.Signal<string | null>;
+    getItemKey(item: T, fallbackIndex?: number): string | number;
+    getItemLabel(item: T): string;
+    getItemDescription(item: T): string | undefined;
+    isItemDisabled(item: T): boolean;
+    readonly filteredSource: _angular_core.Signal<T[]>;
+    readonly filteredTarget: _angular_core.Signal<T[]>;
+    readonly sourceSelectedCount: _angular_core.Signal<number>;
+    readonly isSourceAllSelected: _angular_core.Signal<boolean>;
+    readonly isSourceIndeterminate: _angular_core.Signal<boolean>;
+    readonly targetSelectedCount: _angular_core.Signal<number>;
+    readonly isTargetAllSelected: _angular_core.Signal<boolean>;
+    readonly isTargetIndeterminate: _angular_core.Signal<boolean>;
+    getItemContext(item: T, pane: TransferListPane, index: number): TalosTransferListItemContext<T>;
+    toggleSourceItem(item: T): void;
+    toggleTargetItem(item: T): void;
+    toggleSelectAllSource(): void;
+    toggleSelectAllTarget(): void;
+    private emitSelectionChange;
+    private pruneSelections;
+    onSourceSearch(value: string): void;
+    onTargetSearch(value: string): void;
+    clearSourceSearch(): void;
+    clearTargetSearch(): void;
+    /**
+     * Process asynchronous server-side search request via configured handlers.
+     */
+    private processSearchRequest;
+    moveToTarget(): void;
+    moveAllToTarget(): void;
+    moveToSource(): void;
+    moveAllToSource(): void;
+    moveTargetTop(): void;
+    moveTargetUp(): void;
+    moveTargetDown(): void;
+    moveTargetBottom(): void;
+    onCdkDrop(event: CdkDragDrop<T[]>): void;
+    private notifyChanges;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosTransferListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosTransferListComponent<any>, "talos-transfer-list", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "titles": { "alias": "titles"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchMode": { "alias": "searchMode"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "sourceSearchQuery": { "alias": "sourceSearchQuery"; "required": false; "isSignal": true; }; "targetSearchQuery": { "alias": "targetSearchQuery"; "required": false; "isSignal": true; }; "searchDebounce": { "alias": "searchDebounce"; "required": false; "isSignal": true; }; "searchHandler": { "alias": "searchHandler"; "required": false; "isSignal": true; }; "sourceSearchHandler": { "alias": "sourceSearchHandler"; "required": false; "isSignal": true; }; "targetSearchHandler": { "alias": "targetSearchHandler"; "required": false; "isSignal": true; }; "sourceLoading": { "alias": "sourceLoading"; "required": false; "isSignal": true; }; "targetLoading": { "alias": "targetLoading"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; "isSignal": true; }; "showMoveAll": { "alias": "showMoveAll"; "required": false; "isSignal": true; }; "showReorder": { "alias": "showReorder"; "required": false; "isSignal": true; }; "dragDrop": { "alias": "dragDrop"; "required": false; "isSignal": true; }; "dragMode": { "alias": "dragMode"; "required": false; "isSignal": true; }; "dragHandle": { "alias": "dragHandle"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "listWidth": { "alias": "listWidth"; "required": false; "isSignal": true; }; "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; "itemLabel": { "alias": "itemLabel"; "required": false; "isSignal": true; }; "itemDescription": { "alias": "itemDescription"; "required": false; "isSignal": true; }; "itemDisabled": { "alias": "itemDisabled"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "emptySourceText": { "alias": "emptySourceText"; "required": false; "isSignal": true; }; "emptyTargetText": { "alias": "emptyTargetText"; "required": false; "isSignal": true; }; "searchingText": { "alias": "searchingText"; "required": false; "isSignal": true; }; "noMatchesText": { "alias": "noMatchesText"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "sourceChange": "sourceChange"; "targetChange": "targetChange"; "transfer": "transfer"; "search": "search"; "sourceSearchChange": "sourceSearchChange"; "targetSearchChange": "targetSearchChange"; "searchError": "searchError"; "selectionChange": "selectionChange"; "targetReorder": "targetReorder"; }, never, never, true, never>;
+}
+
+declare class TalosTransferListModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosTransferListModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosTransferListModule, never, [typeof TalosTransferListComponent], [typeof TalosTransferListComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosTransferListModule>;
+}
+
+export { CascadeSelectComponent, DEFAULT_COLOR_PRESETS, DEFAULT_PASSWORD_RULES, DEFAULT_STRENGTH_LABELS, DatePickerComponent, DateRangePickerComponent, DateTimePickerComponent, DateTimeRangePickerComponent, OptionComponent, OptionGroupComponent, SelectInputComponent, SelectInputModule, TALOS_PRESIGNED_UPLOAD_CONFIG, TALOS_PRESIGNED_URL_HANDLER, TalosAffixButtonDirective, TalosAffixModule, TalosAutocompleteComponent, TalosAutocompleteModule, TalosCheckboxComponent, TalosCheckboxDirective, TalosCheckboxGroupComponent, TalosCheckboxGroupDirective, TalosCheckboxModule, TalosCheckboxParentDirective, TalosChipComponent, TalosChipsComponent, TalosChipsModule, TalosColorPickerComponent, TalosColorPickerModule, TalosDropZoneComponent, TalosDropZoneModule, TalosFileDropDirective, TalosFileUploadProgressComponent, TalosFormFieldComponent, TalosFormFieldModule, TalosInputDirective, TalosNumberInputComponent, TalosNumberInputModule, TalosOtpComponent, TalosOtpModule, TalosPasswordInputComponent, TalosPasswordInputDirective, TalosPasswordInputModule, TalosPrefixDirective, TalosPresignedFileUploadComponent, TalosPresignedUploadService, TalosRadioComponent, TalosRadioDirective, TalosRadioGroupComponent, TalosRadioModule, TalosRangeInputComponent, TalosRangeInputDirective, TalosRangeInputModule, TalosRatingComponent, TalosRatingModule, TalosSlideToggleComponent, TalosSlideToggleDirective, TalosSlideToggleModule, TalosSuffixDirective, TalosTextPrefixDirective, TalosTextSuffixDirective, TalosTransferListComponent, TalosTransferListModule };
+export type { AffixAnimation, AffixFeedbackState, AffixPosition, AutocompleteDisplayFn, AutocompleteFilterFn, AutocompleteHighlightPart, AutocompleteItemContext, AutocompleteSize, AutocompleteValueFn, CalendarDay, CalendarMonth, CalendarYear, CascadeExpandTrigger, CascadeOption, CascadeSearchMatch, CascadeValueMode, CheckboxDirection, CheckboxSize, CheckboxVariant, ChipColor, ChipDisplayFn, ChipFilterFn, ChipHighlightPart, ChipItemContext, ChipSize, ChipValueFn, ChipVariant, ColorChangeEvent, ColorPickerSize, ColorPresetGroup, ColorPresetItem, ColumnData, DateRangePreset, DateRangeValue, DropZoneChangeEvent, DropZoneFile, DropZoneFileStatus, DropZoneRejection, DropZoneSize, DropZoneValidatorFn, DropZoneVariant, FileRejectionReason, FormattedAutocompleteOption, FormattedChipOption, InputSize, InternalDateRange, NumberInputSize, NumberInputStepEvent, NumberStepperVariant, OtpCompletedEvent, OtpInputType, OtpSize, OtpSplitConfig, OtpVariant, PasswordInputSize, PasswordMeterVariant, PasswordRule, PasswordRuleStatus, PasswordStrengthLevel, PasswordStrengthResult, PresignedUploadConfig, PresignedUrlHandlerFn, PresignedUrlRequest, PresignedUrlResponse, RadioDirection, RadioSize, RadioVariant, RangeCalendarDay, RangeInputChangeEvent, RangeInputMark, RangeInputSize, RangeInputTick, RangeInputTooltipMode, RangeInputValue, RangeInputVariant, RatingAnimationMode, RatingChangeEvent, RatingHoverEvent, RatingLabelPosition, RatingSize, RatingVariant, SelectedChipData, SlideToggleLabelPosition, SlideToggleSize, SlideToggleVariant, TalosTransferEvent, TalosTransferItem, TalosTransferListItemContext, TalosTransferSelectionChange, TransferListDirection, TransferListDragMode, TransferListFilterFn, TransferListItemDescriptionFn, TransferListItemDisabledFn, TransferListItemKeyFn, TransferListItemLabelFn, TransferListPane, TransferListSearchErrorEvent, TransferListSearchHandler, TransferListSearchMode, TransferListSearchQueryEvent, TransferListSize, TransferListVariant, UploadFileOptions, UploadProgressEvent, UploadTask, UploadTaskStatus };
+//# sourceMappingURL=weeehaoooz-talos-ui-form.d.ts.map