@flusys/ng-ui 6.0.0-beta.1

package/types/flusys-ng-ui.d.ts

@@ -0,0 +1,2384 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, TemplateRef, AfterViewInit, OnDestroy, ElementRef, InjectionToken, Type, Injector, EnvironmentProviders } from '@angular/core';
+import * as i1 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import * as _flusys_ng_ui from '@flusys/ng-ui';
+import * as rxjs from 'rxjs';
+
+interface UiConfirmation {
+    message?: string;
+    header?: string;
+    icon?: string;
+    acceptLabel?: string;
+    rejectLabel?: string;
+    acceptIcon?: string;
+    rejectIcon?: string;
+    acceptButtonStyleClass?: string;
+    rejectButtonStyleClass?: string;
+    closeOnEscape?: boolean;
+    closable?: boolean;
+    acceptVisible?: boolean;
+    rejectVisible?: boolean;
+    accept?: () => void;
+    reject?: () => void;
+    key?: string;
+    target?: EventTarget | null;
+}
+declare class ConfirmationService {
+    private readonly _confirmation;
+    readonly confirmation: _angular_core.Signal<UiConfirmation | null>;
+    confirm(options: UiConfirmation): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ConfirmationService>;
+}
+
+declare class ConfirmDialog {
+    readonly confirmationService: ConfirmationService;
+    readonly key: _angular_core.InputSignal<string | undefined>;
+    readonly activeConfirmation: _angular_core.Signal<UiConfirmation | null>;
+    onEscape(): void;
+    accept(fn?: () => void): void;
+    reject(fn?: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDialog, "f-confirmdialog", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type UiMessageSeverity = 'success' | 'info' | 'warn' | 'error' | 'secondary' | 'contrast';
+interface UiMessage {
+    id: string;
+    severity: UiMessageSeverity;
+    summary?: string;
+    detail?: string;
+    life?: number;
+    sticky?: boolean;
+    key?: string;
+    closing?: boolean;
+}
+interface UiAddMessage {
+    severity?: UiMessageSeverity;
+    summary?: string;
+    detail?: string;
+    life?: number;
+    sticky?: boolean;
+    key?: string;
+}
+declare class MessageService {
+    private readonly _messages;
+    readonly messages: _angular_core.Signal<UiMessage[]>;
+    add(message: UiAddMessage): void;
+    remove(id: string): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MessageService>;
+}
+
+declare class ToastComponent {
+    readonly messageService: MessageService;
+    readonly key: _angular_core.InputSignal<string | undefined>;
+    readonly position: _angular_core.InputSignal<"top-right" | "top-left" | "top-center" | "bottom-right" | "bottom-left" | "bottom-center" | "center">;
+    readonly hostClass: _angular_core.Signal<string>;
+    readonly visibleMessages: _angular_core.Signal<_flusys_ng_ui.UiMessage[]>;
+    severityBg(severity: UiMessageSeverity): string;
+    severityColor(severity: UiMessageSeverity): string;
+    severityBorder(severity: UiMessageSeverity): string;
+    iconName(severity: UiMessageSeverity): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastComponent, "f-toast", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AvatarSize = 'small' | 'normal' | 'large' | 'xlarge';
+type AvatarShape = 'square' | 'circle';
+declare class AvatarComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly image: _angular_core.InputSignal<string>;
+    readonly shape: _angular_core.InputSignal<AvatarShape>;
+    readonly size: _angular_core.InputSignal<AvatarSize>;
+    /** Overrides the default gradient with a solid background color (e.g. a per-user deterministic color). Ignored when `image` is set. */
+    readonly color: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "f-avatar", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "image": { "alias": "image"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AvatarGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroupComponent, "f-avatar-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+type ButtonSeverity = 'primary' | 'secondary' | 'success' | 'info' | 'warn' | 'danger' | 'contrast' | 'help';
+declare class ButtonComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly iconPos: _angular_core.InputSignal<"left" | "right">;
+    readonly severity: _angular_core.InputSignal<ButtonSeverity>;
+    readonly type: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly text: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly link: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly outlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly raised: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly fluid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<"small" | "large" | null>;
+    readonly onClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly hostClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "f-button", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPos": { "alias": "iconPos"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "outlined": { "alias": "outlined"; "required": false; "isSignal": true; }; "raised": { "alias": "raised"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; }, never, ["*"], true, never>;
+}
+
+declare class FButtonDirective {
+    private readonly _el;
+    private readonly _doc;
+    private _appliedContentNodes;
+    readonly severity: _angular_core.InputSignal<ButtonSeverity>;
+    readonly text: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly outlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly link: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly raised: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly fluid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<"small" | "large" | null>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly iconPos: _angular_core.InputSignal<"left" | "right">;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly plain: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hostClass: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FButtonDirective, "[fButton]", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "outlined": { "alias": "outlined"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "raised": { "alias": "raised"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPos": { "alias": "iconPos"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "plain": { "alias": "plain"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ChipComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onRemove: _angular_core.OutputEmitterRef<MouseEvent>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipComponent, "f-chip", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; }, { "onRemove": "onRemove"; }, never, never, true, never>;
+}
+
+declare class DividerComponent {
+    readonly layout: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly type: _angular_core.InputSignal<"solid" | "dashed" | "dotted">;
+    readonly align: _angular_core.InputSignal<"center" | "left" | "right">;
+    readonly segmentClass: _angular_core.Signal<string>;
+    readonly beforeClass: _angular_core.Signal<"flex-none w-8" | "flex-1">;
+    readonly afterClass: _angular_core.Signal<"flex-none w-8" | "flex-1">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "f-divider", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*", "*"], true, never>;
+}
+
+declare class ImageComponent {
+    readonly src: _angular_core.InputSignal<string>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly preview: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onShow: _angular_core.OutputEmitterRef<void>;
+    readonly onHide: _angular_core.OutputEmitterRef<void>;
+    private readonly _previewVisible;
+    readonly previewVisible: _angular_core.Signal<boolean>;
+    open(): void;
+    close(): void;
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageComponent, "f-image", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "preview": { "alias": "preview"; "required": false; "isSignal": true; }; }, { "onShow": "onShow"; "onHide": "onHide"; }, never, never, true, never>;
+}
+
+declare class MessageComponent {
+    readonly severity: _angular_core.InputSignal<"info" | "success" | "warn" | "error">;
+    readonly text: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    readonly iconName: _angular_core.Signal<string>;
+    readonly iconColor: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageComponent, "f-message", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ProgressbarComponent {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly mode: _angular_core.InputSignal<"determinate" | "indeterminate">;
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressbarComponent, "f-progressbar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ProgressSpinnerComponent {
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressSpinnerComponent, "f-progressspinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SkeletonComponent {
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly borderRadius: _angular_core.InputSignal<string>;
+    readonly shape: _angular_core.InputSignal<"circle" | "rectangle">;
+    readonly hostStyle: _angular_core.Signal<{
+        width: string;
+        height: string;
+        borderRadius: string;
+        display: string;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonComponent, "f-skeleton", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type TagSeverity = 'success' | 'info' | 'warn' | 'danger' | 'secondary' | 'contrast' | null;
+declare class TagComponent {
+    readonly value: _angular_core.InputSignal<string>;
+    readonly severity: _angular_core.InputSignal<TagSeverity>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Overrides severity with a custom background/text color (e.g. a per-entity color). */
+    readonly color: _angular_core.InputSignal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    readonly inlineStyle: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "f-tag", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface CheckboxChangeEvent {
+    checked: boolean;
+    originalEvent: Event;
+}
+declare class CheckboxComponent implements ControlValueAccessor {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly binary: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly onChangeEvent: _angular_core.OutputEmitterRef<CheckboxChangeEvent>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    private _onChange;
+    private _onTouched;
+    onChange(event: Event): void;
+    handleBlur(): void;
+    writeValue(val: boolean): void;
+    registerOnChange(fn: (v: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "f-checkbox", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "binary": { "alias": "binary"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "onChangeEvent": "onChange"; "onBlur": "onBlur"; "touch": "touch"; "checked": "checkedChange"; }, never, never, true, never>;
+}
+
+declare class DatePickerComponent implements ControlValueAccessor {
+    readonly MONTHS: string[];
+    readonly DAYS: string[];
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showTime: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectionMode: _angular_core.InputSignal<"single" | "range" | "multiple">;
+    readonly minDate: _angular_core.InputSignal<Date | null | undefined>;
+    readonly maxDate: _angular_core.InputSignal<Date | null | undefined>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputStyleClass: _angular_core.InputSignal<string>;
+    readonly showIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showButtonBar: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly appendTo: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<Date | null>;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private readonly _viewMonth;
+    readonly viewMonth: _angular_core.Signal<number>;
+    private readonly _viewYear;
+    readonly viewYear: _angular_core.Signal<number>;
+    readonly wrapperClass: _angular_core.Signal<string>;
+    private readonly _el;
+    private _onChange;
+    private _onTouched;
+    readonly displayValue: _angular_core.Signal<string>;
+    readonly calendarDays: _angular_core.Signal<{
+        day: number;
+        date?: Date;
+        selected: boolean;
+        pad: boolean;
+        disabled: boolean;
+    }[]>;
+    dayClass(day: {
+        selected: boolean;
+        pad: boolean;
+        disabled: boolean;
+    }): string;
+    private isOutOfRange;
+    private formatDate;
+    onDocumentClick(e: MouseEvent): void;
+    toggleCalendar(): void;
+    clear(event: Event): void;
+    selectDate(date: Date): void;
+    onTodayClick(): void;
+    onClearClick(): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    writeValue(v: Date | null): void;
+    registerOnChange(fn: (v: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerComponent, "f-datepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "inputStyleClass": { "alias": "inputStyleClass"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "showButtonBar": { "alias": "showButtonBar"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, { "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+interface FileSelectEvent {
+    files: File[];
+    currentFiles: File[];
+}
+interface FileRemoveEvent {
+    file: File;
+}
+interface FileErrorEvent {
+    file: File;
+    reason: 'size' | 'count';
+}
+declare class FileUploadComponent {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly auto: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly maxFileSize: _angular_core.InputSignal<number | null>;
+    readonly fileLimit: _angular_core.InputSignal<number | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly url: _angular_core.InputSignal<string>;
+    readonly customUpload: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showUploadButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showCancelButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly chooseLabel: _angular_core.InputSignal<string>;
+    readonly chooseIcon: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly mode: _angular_core.InputSignal<string>;
+    readonly onSelect: _angular_core.OutputEmitterRef<FileSelectEvent>;
+    readonly onRemove: _angular_core.OutputEmitterRef<FileRemoveEvent>;
+    readonly onClear: _angular_core.OutputEmitterRef<void>;
+    readonly onError: _angular_core.OutputEmitterRef<FileErrorEvent[]>;
+    private readonly _files;
+    readonly files: _angular_core.Signal<File[]>;
+    private readonly _isDragging;
+    readonly isDragging: _angular_core.Signal<boolean>;
+    onDragOver(e: DragEvent): void;
+    onDragLeave(): void;
+    onFileChange(e: Event): void;
+    onDrop(e: DragEvent): void;
+    private acceptIncoming;
+    removeFile(file: File): void;
+    clear(): void;
+    formatSize(bytes: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploadComponent, "f-fileupload", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "auto": { "alias": "auto"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "fileLimit": { "alias": "fileLimit"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "customUpload": { "alias": "customUpload"; "required": false; "isSignal": true; }; "showUploadButton": { "alias": "showUploadButton"; "required": false; "isSignal": true; }; "showCancelButton": { "alias": "showCancelButton"; "required": false; "isSignal": true; }; "chooseLabel": { "alias": "chooseLabel"; "required": false; "isSignal": true; }; "chooseIcon": { "alias": "chooseIcon"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; "onRemove": "onRemove"; "onClear": "onClear"; "onError": "onError"; }, never, never, true, never>;
+}
+
+declare class IconFieldComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconFieldComponent, "f-iconfield", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class InputIconComponent {
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly hostClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputIconComponent, "f-inputicon", never, { "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class InputNumberComponent implements ControlValueAccessor {
+    readonly min: _angular_core.InputSignal<number | null>;
+    readonly max: _angular_core.InputSignal<number | null>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly showButtons: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly prefix: _angular_core.InputSignal<string>;
+    readonly suffix: _angular_core.InputSignal<string>;
+    readonly useGrouping: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly buttonLayout: _angular_core.InputSignal<"horizontal" | "stacked">;
+    readonly inputStyleClass: _angular_core.InputSignal<string>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<number | null>;
+    private readonly _formDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    readonly wrapperClass: _angular_core.Signal<string>;
+    private _onChange;
+    private _onTouched;
+    onInputChange(e: Event): void;
+    increment(): void;
+    decrement(): void;
+    handleBlur(): void;
+    writeValue(v: number): void;
+    registerOnChange(fn: (v: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputNumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputNumberComponent, "f-inputnumber", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "useGrouping": { "alias": "useGrouping"; "required": false; "isSignal": true; }; "buttonLayout": { "alias": "buttonLayout"; "required": false; "isSignal": true; }; "inputStyleClass": { "alias": "inputStyleClass"; "required": false; "isSignal": true; }; }, { "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+declare class InputTextDirective implements OnInit {
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    private readonly _el;
+    private readonly _iconLeft;
+    ngOnInit(): void;
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputTextDirective, "[fInputText]", never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InputPasswordDirective {
+    private readonly _el;
+    readonly mask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputPasswordDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputPasswordDirective, "[fInputPassword]", never, { "mask": { "alias": "mask"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MultiSelectComponent implements ControlValueAccessor {
+    private readonly _el;
+    onDocumentClick(e: MouseEvent): void;
+    readonly triggerClass: _angular_core.Signal<string>;
+    readonly options: _angular_core.InputSignal<unknown[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly optionDisabled: _angular_core.InputSignal<string>;
+    readonly display: _angular_core.InputSignal<string>;
+    readonly maxSelectedLabels: _angular_core.InputSignal<number>;
+    readonly selectionLimit: _angular_core.InputSignal<number | null>;
+    readonly showToggleAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    private readonly _values;
+    readonly values: _angular_core.Signal<unknown[]>;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private readonly _filterText;
+    readonly filterText: _angular_core.Signal<string>;
+    private _onChange;
+    private _onTouched;
+    readonly filteredOptions: _angular_core.Signal<Record<string, unknown>[]>;
+    readonly selectedLabels: _angular_core.Signal<string[]>;
+    getOptionLabel(opt: unknown): string;
+    getOptionValue(opt: unknown): unknown;
+    isSelected(opt: unknown): boolean;
+    isOptionDisabled(opt: unknown): boolean;
+    readonly commaLabel: _angular_core.Signal<string>;
+    onFilterInput(v: string): void;
+    toggleOpen(): void;
+    toggleOption(e: Event, opt: unknown): void;
+    clearAll(e: Event): void;
+    readonly allFilteredSelected: _angular_core.Signal<boolean>;
+    toggleAll(e: Event): void;
+    removeByLabel(e: Event, lbl: string): void;
+    writeValue(v: unknown[]): void;
+    registerOnChange(fn: (v: unknown[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiSelectComponent, "f-multiselect", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "maxSelectedLabels": { "alias": "maxSelectedLabels"; "required": false; "isSignal": true; }; "selectionLimit": { "alias": "selectionLimit"; "required": false; "isSignal": true; }; "showToggleAll": { "alias": "showToggleAll"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, { "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+declare class PasswordComponent implements ControlValueAccessor {
+    readonly toggleMask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly feedback: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly inputStyleClass: _angular_core.InputSignal<string>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<string>;
+    private readonly _show;
+    readonly show: _angular_core.Signal<boolean>;
+    readonly strength: _angular_core.Signal<{
+        segments: number;
+        label: string;
+        color: string;
+    }>;
+    readonly inputClass: _angular_core.Signal<string>;
+    private _onChange;
+    private _onTouched;
+    onInput(e: Event): void;
+    handleBlur(): void;
+    toggleShow(): void;
+    writeValue(v: string): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PasswordComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasswordComponent, "f-password", never, { "toggleMask": { "alias": "toggleMask"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "inputStyleClass": { "alias": "inputStyleClass"; "required": false; "isSignal": true; }; }, { "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+interface RadioButtonClickEvent {
+    originalEvent: Event;
+    value: unknown;
+}
+declare class RadioButtonComponent implements ControlValueAccessor {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly onClick: _angular_core.OutputEmitterRef<RadioButtonClickEvent>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    private readonly _modelValue;
+    readonly modelValue: _angular_core.Signal<unknown>;
+    private _onChange;
+    private _onTouched;
+    isChecked(): boolean;
+    onChange(e: Event): void;
+    handleBlur(): void;
+    writeValue(v: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioButtonComponent, "f-radiobutton", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+declare class RatingComponent implements ControlValueAccessor {
+    readonly stars: _angular_core.InputSignal<number>;
+    readonly cancel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly iconOn: _angular_core.InputSignal<string>;
+    readonly iconOff: _angular_core.InputSignal<string>;
+    readonly onRate: _angular_core.OutputEmitterRef<{
+        value: number;
+    }>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<number>;
+    private readonly _hovered;
+    readonly hovered: _angular_core.Signal<number>;
+    readonly starsArray: _angular_core.Signal<number[]>;
+    private _onChange;
+    private _onTouched;
+    onHover(v: number): void;
+    setValue(v: number): void;
+    writeValue(v: number): void;
+    registerOnChange(fn: (v: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RatingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RatingComponent, "f-rating", never, { "stars": { "alias": "stars"; "required": false; "isSignal": true; }; "cancel": { "alias": "cancel"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "iconOn": { "alias": "iconOn"; "required": false; "isSignal": true; }; "iconOff": { "alias": "iconOff"; "required": false; "isSignal": true; }; }, { "onRate": "onRate"; "onBlur": "onBlur"; }, never, never, true, never>;
+}
+
+declare class FTemplateDirective {
+    readonly fTemplate: _angular_core.InputSignal<string>;
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FTemplateDirective, "ng-template[fTemplate]", never, { "fTemplate": { "alias": "fTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SelectComponent implements ControlValueAccessor {
+    private readonly _el;
+    onDocumentClick(e: MouseEvent): void;
+    readonly options: _angular_core.InputSignal<unknown[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly editable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hostClass: _angular_core.Signal<string>;
+    readonly onFilter: _angular_core.OutputEmitterRef<{
+        filter: string;
+    }>;
+    readonly onChange: _angular_core.OutputEmitterRef<unknown>;
+    readonly onShow: _angular_core.OutputEmitterRef<void>;
+    readonly onHide: _angular_core.OutputEmitterRef<void>;
+    readonly onBlur: _angular_core.OutputEmitterRef<void>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<unknown>;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private readonly _filterText;
+    readonly filterText: _angular_core.Signal<string>;
+    readonly selectedItemRef: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly itemRef: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly fTemplates: _angular_core.Signal<readonly FTemplateDirective[]>;
+    readonly selectedItemTpl: _angular_core.Signal<TemplateRef<unknown> | null>;
+    readonly itemTpl: _angular_core.Signal<TemplateRef<unknown> | null>;
+    private _onChange;
+    private _onTouched;
+    setFilter(v: string): void;
+    readonly filteredOptions: _angular_core.Signal<Record<string, unknown>[]>;
+    readonly selectedLabel: _angular_core.Signal<string>;
+    readonly triggerClass: _angular_core.Signal<string>;
+    readonly selectedOption: _angular_core.Signal<Record<string, unknown> | null>;
+    getOptionLabel(opt: unknown): string;
+    getOptionValue(opt: unknown): unknown;
+    private readonly _editableOverride;
+    readonly editableText: _angular_core.Signal<string>;
+    onEditableInput(text: string): void;
+    clear(event: Event): void;
+    toggleOpen(): void;
+    selectOption(opt: unknown): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "f-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, { "onFilter": "onFilter"; "onChange": "onChange"; "onShow": "onShow"; "onHide": "onHide"; "onBlur": "onBlur"; }, ["selectedItemRef", "itemRef", "fTemplates"], never, true, never>;
+}
+
+declare class SelectButtonComponent implements ControlValueAccessor {
+    readonly options: _angular_core.InputSignal<unknown[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly allowEmpty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<string>;
+    readonly onChange: _angular_core.OutputEmitterRef<{
+        value: unknown;
+    }>;
+    private _value;
+    private _values;
+    private _onChange;
+    private _onTouched;
+    getOptionLabel(opt: unknown): string;
+    getOptionValue(opt: unknown): unknown;
+    isSelected(opt: unknown): boolean;
+    select(opt: unknown): void;
+    writeValue(v: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectButtonComponent, "f-selectbutton", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "onChange": "onChange"; }, never, never, true, never>;
+}
+
+declare class TextareaDirective {
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextareaDirective, "[fTextarea]", never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ToggleButtonComponent implements ControlValueAccessor {
+    readonly onLabel: _angular_core.InputSignal<string>;
+    readonly offLabel: _angular_core.InputSignal<string>;
+    readonly onIcon: _angular_core.InputSignal<string>;
+    readonly offIcon: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _checked;
+    readonly checked: _angular_core.Signal<boolean>;
+    private _onChange;
+    private _onTouched;
+    readonly buttonClass: _angular_core.Signal<string>;
+    toggle(): void;
+    writeValue(v: boolean): void;
+    registerOnChange(fn: (v: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleButtonComponent, "f-togglebutton", never, { "onLabel": { "alias": "onLabel"; "required": false; "isSignal": true; }; "offLabel": { "alias": "offLabel"; "required": false; "isSignal": true; }; "onIcon": { "alias": "onIcon"; "required": false; "isSignal": true; }; "offIcon": { "alias": "offIcon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ToggleSwitchComponent implements ControlValueAccessor {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly trueValue: _angular_core.InputSignal<unknown>;
+    readonly falseValue: _angular_core.InputSignal<unknown>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    private readonly _checked;
+    readonly checked: _angular_core.Signal<boolean>;
+    private readonly _formDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    private _onChange;
+    private _onTouched;
+    readonly trackClass: _angular_core.Signal<string>;
+    readonly thumbClass: _angular_core.Signal<string>;
+    toggle(): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleSwitchComponent, "f-toggleswitch", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "trueValue": { "alias": "trueValue"; "required": false; "isSignal": true; }; "falseValue": { "alias": "falseValue"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DialogComponent {
+    private static idCounter;
+    private readonly _doc;
+    protected readonly headerId: string;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly visible: _angular_core.ModelSignal<boolean>;
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dismissableMask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly resizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly style: _angular_core.InputSignal<Record<string, string> | null>;
+    readonly breakpoints: _angular_core.InputSignal<Record<string, string> | null>;
+    private readonly _resizedSize;
+    private readonly _windowWidth;
+    private readonly breakpointWidth;
+    readonly panelStyle: _angular_core.Signal<Record<string, string>>;
+    readonly onShow: _angular_core.OutputEmitterRef<void>;
+    readonly onHide: _angular_core.OutputEmitterRef<void>;
+    readonly footerRef: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly fTemplates: _angular_core.Signal<readonly FTemplateDirective[]>;
+    readonly resolvedFooter: _angular_core.Signal<TemplateRef<unknown> | null>;
+    private readonly _rendered;
+    readonly rendered: _angular_core.Signal<boolean>;
+    private readonly _closing;
+    readonly closing: _angular_core.Signal<boolean>;
+    constructor();
+    close(): void;
+    onResizeStart(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogComponent, "f-dialog", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "dismissableMask": { "alias": "dismissableMask"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "breakpoints": { "alias": "breakpoints"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "onShow": "onShow"; "onHide": "onHide"; }, ["footerRef", "fTemplates"], ["*"], true, never>;
+}
+
+declare class DrawerComponent {
+    readonly header: _angular_core.InputSignal<string>;
+    readonly visible: _angular_core.ModelSignal<boolean>;
+    readonly position: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">;
+    readonly fullScreen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onHide: _angular_core.OutputEmitterRef<void>;
+    readonly panelClass: _angular_core.Signal<string>;
+    private readonly _rendered;
+    readonly rendered: _angular_core.Signal<boolean>;
+    private readonly _closing;
+    readonly closing: _angular_core.Signal<boolean>;
+    constructor();
+    onEscape(): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DrawerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DrawerComponent, "f-drawer", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "fullScreen": { "alias": "fullScreen"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "onHide": "onHide"; }, never, ["*"], true, never>;
+}
+
+declare class PopoverComponent {
+    readonly dismissable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _visible;
+    readonly visible: _angular_core.Signal<boolean>;
+    private readonly _top;
+    readonly top: _angular_core.Signal<number>;
+    private readonly _left;
+    readonly left: _angular_core.Signal<number>;
+    private readonly panelRef;
+    private _anchor;
+    toggle(event: Event): void;
+    show(event: Event): void;
+    hide(): void;
+    private position;
+    private adjustForViewport;
+    onDocumentClick(e: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverComponent, "f-popover", never, { "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class CardComponent {
+    readonly header: _angular_core.InputSignal<string>;
+    readonly subheader: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly footerTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "f-card", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "subheader": { "alias": "subheader"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate", "footerTemplate"], ["*"], true, never>;
+}
+
+declare class PanelComponent {
+    readonly header: _angular_core.InputSignal<string>;
+    readonly toggleable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapsed: _angular_core.ModelSignal<boolean>;
+    toggleCollapsed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PanelComponent, "f-panel", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+interface MenuItemCommandEvent {
+    originalEvent?: Event;
+    item?: MenuItem;
+}
+interface MenuItem {
+    label?: string;
+    icon?: string;
+    iconClass?: string;
+    command?: (event: MenuItemCommandEvent) => void;
+    url?: string;
+    routerLink?: string | string[];
+    queryParams?: Record<string, unknown>;
+    items?: MenuItem[];
+    disabled?: boolean;
+    visible?: boolean;
+    separator?: boolean;
+    /** Marks the item as the current selection — renders a highlight and a trailing check mark. */
+    selected?: boolean;
+    styleClass?: string;
+    badge?: string;
+    badgeStyleClass?: string;
+    tooltip?: string;
+    tooltipPosition?: 'top' | 'bottom' | 'left' | 'right';
+    target?: string;
+    id?: string;
+    escape?: boolean;
+    tabindex?: string;
+    automationId?: unknown;
+    expanded?: boolean;
+    state?: Record<string, unknown>;
+    style?: Record<string, string>;
+    [key: string]: unknown;
+}
+
+type StepsMenuItem = MenuItem;
+declare class StepsComponent {
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly activeIndex: _angular_core.InputSignal<number>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onActiveIndexChange: _angular_core.OutputEmitterRef<number>;
+    stepCircleClass(i: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepsComponent, "f-steps", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "onActiveIndexChange": "onActiveIndexChange"; }, never, never, true, never>;
+}
+
+declare class SplitterComponent {
+    readonly layout: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly panelSizes: _angular_core.InputSignal<number[]>;
+    readonly minSizes: _angular_core.InputSignal<number[]>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly panelTemplates: _angular_core.Signal<readonly FTemplateDirective[]>;
+    private readonly _sizes;
+    readonly sizes: _angular_core.Signal<number[]>;
+    constructor();
+    panelFlex(index: number): string;
+    onGutterPointerDown(event: PointerEvent, index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplitterComponent, "f-splitter", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "panelSizes": { "alias": "panelSizes"; "required": false; "isSignal": true; }; "minSizes": { "alias": "minSizes"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, ["panelTemplates"], ["*"], true, never>;
+}
+declare class SplitterPanelComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitterPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplitterPanelComponent, "f-splitter-panel", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ToolbarComponent {
+    readonly styleClass: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToolbarComponent, "f-toolbar", never, { "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, ["[start],[fStart]", "[center],[fCenter]", "[end],[fEnd]", "*"], true, never>;
+}
+
+declare class TabsComponent {
+    readonly value: _angular_core.ModelSignal<string | number>;
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onTabChange: _angular_core.OutputEmitterRef<{
+        value: string | number;
+    }>;
+    private readonly ctx;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "f-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onTabChange": "onTabChange"; }, never, ["*"], true, never>;
+}
+declare class TabListComponent {
+    private readonly ctx;
+    private readonly tabs;
+    readonly listClass: _angular_core.Signal<"flex border-b border-(--f-content-border-color) gap-0 scrollbar-none overflow-x-auto" | "flex border-b border-(--f-content-border-color) gap-0 scrollbar-none flex-wrap">;
+    onKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabListComponent, "f-tablist", never, {}, {}, ["tabs"], ["*"], true, never>;
+}
+declare class TabComponent {
+    private readonly ctx;
+    private readonly buttonRef;
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isActive: _angular_core.Signal<boolean>;
+    readonly triggerId: _angular_core.Signal<string>;
+    readonly panelId: _angular_core.Signal<string>;
+    readonly tabClass: _angular_core.Signal<"px-4 py-2.5 text-sm font-medium whitespace-nowrap border-b-[2.5px] transition-all duration-[var(--f-transition-duration)] -mb-px inline-flex items-center gap-1.5 focus:outline-none focus-visible:ring-focus cursor-pointer disabled:cursor-not-allowed disabled:opacity-40 select-none border-primary text-primary" | "px-4 py-2.5 text-sm font-medium whitespace-nowrap border-b-[2.5px] transition-all duration-[var(--f-transition-duration)] -mb-px inline-flex items-center gap-1.5 focus:outline-none focus-visible:ring-focus cursor-pointer disabled:cursor-not-allowed disabled:opacity-40 select-none border-transparent text-(--f-text-muted-color) hover:text-(--f-text-hover-color) hover:border-(--f-content-border-color) hover:bg-(--f-content-hover-background)/60">;
+    buttonEl(): HTMLButtonElement | undefined;
+    focusButton(): void;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabComponent, "f-tab", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TabPanelsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanelsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabPanelsComponent, "f-tabpanels", never, {}, {}, never, ["*"], true, never>;
+}
+declare class TabPanelComponent {
+    private readonly ctx;
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isActive: _angular_core.Signal<boolean>;
+    readonly triggerId: _angular_core.Signal<string>;
+    readonly panelId: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabPanelComponent, "f-tabpanel", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class AccordionContext {
+    private readonly _values;
+    readonly values: _angular_core.Signal<(string | number)[]>;
+    private readonly _multiple;
+    readonly multiple: _angular_core.Signal<boolean>;
+    isOpen(v: string | number): boolean;
+    toggle(v: string | number): void;
+    setValues(vals: (string | number)[]): void;
+    setMultiple(v: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AccordionContext>;
+}
+declare class AccordionPanelCtx {
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private _toggleFn;
+    setToggleFn(fn: () => void): void;
+    toggle(): void;
+    setOpen(v: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionPanelCtx, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AccordionPanelCtx>;
+}
+
+declare class AccordionComponent implements OnInit {
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.ModelSignal<string | number | (string | number)[] | null>;
+    readonly onOpen: _angular_core.OutputEmitterRef<{
+        value: string | number;
+    }>;
+    readonly onClose: _angular_core.OutputEmitterRef<{
+        value: string | number;
+    }>;
+    private readonly ctx;
+    ngOnInit(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionComponent, "f-accordion", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onOpen": "onOpen"; "onClose": "onClose"; }, never, ["*"], true, never>;
+}
+declare class AccordionPanelComponent implements OnInit {
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly panelCtx;
+    private readonly accordionCtx;
+    ngOnInit(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionPanelComponent, "f-accordion-panel", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AccordionHeaderComponent {
+    readonly panelCtx: AccordionPanelCtx;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionHeaderComponent, "f-accordion-header", never, {}, {}, never, ["*"], true, never>;
+}
+declare class AccordionContentComponent {
+    readonly panelCtx: AccordionPanelCtx;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionContentComponent, "f-accordion-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ChartComponent implements AfterViewInit, OnDestroy {
+    private readonly platformId;
+    readonly type: _angular_core.InputSignal<string>;
+    readonly data: _angular_core.InputSignal<unknown>;
+    readonly options: _angular_core.InputSignal<unknown>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly canvasRef: _angular_core.Signal<ElementRef<HTMLCanvasElement> | undefined>;
+    private chart;
+    private currentType;
+    constructor();
+    ngAfterViewInit(): void;
+    private recreateChart;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartComponent, "f-chart", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface PaginatorState {
+    first: number;
+    rows: number;
+    page: number;
+    pageCount: number;
+}
+declare class PaginatorComponent {
+    readonly first: _angular_core.InputSignal<number>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly totalRecords: _angular_core.InputSignal<number>;
+    readonly rowsPerPageOptions: _angular_core.InputSignal<number[]>;
+    readonly showCurrentPageReport: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly currentPageReportTemplate: _angular_core.InputSignal<string>;
+    readonly onPageChange: _angular_core.OutputEmitterRef<PaginatorState>;
+    readonly currentPage: _angular_core.Signal<number>;
+    readonly pageCount: _angular_core.Signal<number>;
+    readonly reportText: _angular_core.Signal<string>;
+    readonly visiblePages: _angular_core.Signal<number[]>;
+    pageClass(p: number): string;
+    goTo(page: number): void;
+    onRowsChange(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginatorComponent, "f-paginator", never, { "first": { "alias": "first"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "totalRecords": { "alias": "totalRecords"; "required": false; "isSignal": true; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; "isSignal": true; }; "showCurrentPageReport": { "alias": "showCurrentPageReport"; "required": false; "isSignal": true; }; "currentPageReportTemplate": { "alias": "currentPageReportTemplate"; "required": false; "isSignal": true; }; }, { "onPageChange": "onPageChange"; }, never, never, true, never>;
+}
+
+declare class SortableColumnDirective {
+    readonly fSortableColumn: _angular_core.InputSignal<string>;
+    private readonly table;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortableColumnDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SortableColumnDirective, "[fSortableColumn]", never, { "fSortableColumn": { "alias": "fSortableColumn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SortIconComponent {
+    readonly field: _angular_core.InputSignal<string>;
+    private readonly table;
+    readonly direction: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SortIconComponent, "f-sorticon", never, { "field": { "alias": "field"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class StyleClassDirective implements OnDestroy {
+    private readonly el;
+    private readonly doc;
+    readonly fStyleClass: _angular_core.InputSignal<string>;
+    readonly enterFromClass: _angular_core.InputSignal<string>;
+    readonly enterActiveClass: _angular_core.InputSignal<string>;
+    readonly enterToClass: _angular_core.InputSignal<string>;
+    readonly leaveFromClass: _angular_core.InputSignal<string>;
+    readonly leaveActiveClass: _angular_core.InputSignal<string>;
+    readonly leaveToClass: _angular_core.InputSignal<string>;
+    readonly hideOnOutsideClick: _angular_core.InputSignal<boolean>;
+    readonly toggleClass: _angular_core.InputSignal<string>;
+    private outsideClickListener;
+    onClick(): void;
+    ngOnDestroy(): void;
+    private enter;
+    private leave;
+    private bindOutsideClick;
+    private unbindOutsideClick;
+    private resolveTarget;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StyleClassDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StyleClassDirective, "[fStyleClass]", never, { "fStyleClass": { "alias": "fStyleClass"; "required": false; "isSignal": true; }; "enterFromClass": { "alias": "enterFromClass"; "required": false; "isSignal": true; }; "enterActiveClass": { "alias": "enterActiveClass"; "required": false; "isSignal": true; }; "enterToClass": { "alias": "enterToClass"; "required": false; "isSignal": true; }; "leaveFromClass": { "alias": "leaveFromClass"; "required": false; "isSignal": true; }; "leaveActiveClass": { "alias": "leaveActiveClass"; "required": false; "isSignal": true; }; "leaveToClass": { "alias": "leaveToClass"; "required": false; "isSignal": true; }; "hideOnOutsideClick": { "alias": "hideOnOutsideClick"; "required": false; "isSignal": true; }; "toggleClass": { "alias": "toggleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TableLazyLoadEvent {
+    first: number;
+    rows: number;
+    sortField?: string;
+    sortOrder?: number;
+}
+interface TableSortEvent {
+    sortField: string | null;
+    sortOrder: number;
+}
+declare class TableComponent implements OnInit {
+    readonly value: _angular_core.InputSignal<unknown[] | null>;
+    readonly lazy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly totalRecords: _angular_core.InputSignal<number>;
+    readonly rowHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dataKey: _angular_core.InputSignal<string>;
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly paginator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly first: _angular_core.InputSignal<number>;
+    readonly rowsPerPageOptions: _angular_core.InputSignal<number[]>;
+    readonly showCurrentPageReport: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly currentPageReportTemplate: _angular_core.InputSignal<string>;
+    readonly tableStyle: _angular_core.InputSignal<Record<string, string> | null>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly globalFilterFields: _angular_core.InputSignal<string[]>;
+    readonly sortField: _angular_core.ModelSignal<string | null>;
+    readonly sortOrder: _angular_core.ModelSignal<number>;
+    readonly onLazyLoad: _angular_core.OutputEmitterRef<TableLazyLoadEvent>;
+    readonly onSort: _angular_core.OutputEmitterRef<TableSortEvent>;
+    readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly bodyTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly emptyTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    private readonly _currentFirst;
+    private readonly _currentRows;
+    readonly currentFirst: _angular_core.Signal<number>;
+    readonly currentRows: _angular_core.Signal<number>;
+    private readonly _filterText;
+    readonly filterText: _angular_core.Signal<string>;
+    readonly filteredValue: _angular_core.Signal<unknown[]>;
+    readonly sortedValue: _angular_core.Signal<unknown[]>;
+    readonly effectiveTotalRecords: _angular_core.Signal<number>;
+    readonly pageRows: _angular_core.Signal<unknown[]>;
+    ngOnInit(): void;
+    onFilterInput(v: string): void;
+    trackByRow(index: number, row: unknown): unknown;
+    handlePageChange(event: PaginatorState): void;
+    sort(field: string): void;
+    private buildLazyEvent;
+    private compareValues;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent, "f-table", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "totalRecords": { "alias": "totalRecords"; "required": false; "isSignal": true; }; "rowHover": { "alias": "rowHover"; "required": false; "isSignal": true; }; "dataKey": { "alias": "dataKey"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "first": { "alias": "first"; "required": false; "isSignal": true; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; "isSignal": true; }; "showCurrentPageReport": { "alias": "showCurrentPageReport"; "required": false; "isSignal": true; }; "currentPageReportTemplate": { "alias": "currentPageReportTemplate"; "required": false; "isSignal": true; }; "tableStyle": { "alias": "tableStyle"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "globalFilterFields": { "alias": "globalFilterFields"; "required": false; "isSignal": true; }; "sortField": { "alias": "sortField"; "required": false; "isSignal": true; }; "sortOrder": { "alias": "sortOrder"; "required": false; "isSignal": true; }; }, { "sortField": "sortFieldChange"; "sortOrder": "sortOrderChange"; "onLazyLoad": "onLazyLoad"; "onSort": "onSort"; }, ["headerTemplate", "bodyTemplate", "emptyTemplate"], never, true, never>;
+}
+
+declare class TooltipDirective implements OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    private readonly platformId;
+    readonly fTooltip: _angular_core.InputSignal<string>;
+    readonly tooltipPosition: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">;
+    readonly tooltipStyleClass: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tooltipEvent: _angular_core.InputSignal<"focus" | "hover" | "both">;
+    readonly showDelay: _angular_core.InputSignal<number>;
+    readonly hideDelay: _angular_core.InputSignal<number>;
+    private tip;
+    private showTimer;
+    private hideTimer;
+    private readonly onScrollOrResize;
+    onFocus(): void;
+    scheduleShow(): void;
+    scheduleHide(): void;
+    show(): void;
+    hide(): void;
+    private position;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[fTooltip]", never, { "fTooltip": { "alias": "fTooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipStyleClass": { "alias": "tooltipStyleClass"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tooltipEvent": { "alias": "tooltipEvent"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AutoCompleteCompleteEvent {
+    originalEvent: Event;
+    query: string;
+}
+interface AutoCompleteSelectEvent {
+    originalEvent: Event;
+    value: unknown;
+}
+declare class AutoCompleteComponent implements ControlValueAccessor {
+    private readonly _el;
+    onDocumentClick(e: MouseEvent): void;
+    readonly suggestions: _angular_core.InputSignal<unknown[]>;
+    readonly field: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dropdown: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly forceSelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly completeOnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly delay: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly minLength: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly completeMethod: _angular_core.OutputEmitterRef<AutoCompleteCompleteEvent>;
+    readonly onSelect: _angular_core.OutputEmitterRef<AutoCompleteSelectEvent>;
+    readonly onUnselect: _angular_core.OutputEmitterRef<{
+        originalEvent: Event;
+        value: unknown;
+    }>;
+    readonly onDropdownClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly onClear: _angular_core.OutputEmitterRef<void>;
+    readonly focusEvent: _angular_core.OutputEmitterRef<void>;
+    readonly blurEvent: _angular_core.OutputEmitterRef<void>;
+    readonly onChange: _angular_core.OutputEmitterRef<unknown>;
+    query: string;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private readonly _activeIndex;
+    readonly activeIndex: _angular_core.Signal<number>;
+    private readonly _selectedItems;
+    readonly selectedItems: _angular_core.Signal<unknown[]>;
+    private _value;
+    private _onChange;
+    private _onTouched;
+    private _debounce?;
+    readonly filteredSuggestions: _angular_core.Signal<unknown[]>;
+    readonly inputClass: _angular_core.Signal<string>;
+    onDropdownButtonClick(e: MouseEvent): void;
+    readonly wrapperClass: _angular_core.Signal<"border-primary" | "border-(--f-form-field-border-color) hover:border-(--f-form-field-hover-border-color)">;
+    getLabel(item: unknown): string;
+    onQueryChange(q: string): void;
+    _handleFocus(): void;
+    _handleBlur(): void;
+    onKeyDown(e: KeyboardEvent): void;
+    selectItem(e: Event, item: unknown): void;
+    removeChip(idx: number, e: Event): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoCompleteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutoCompleteComponent, "f-autocomplete", never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dropdown": { "alias": "dropdown"; "required": false; "isSignal": true; }; "forceSelection": { "alias": "forceSelection"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "completeOnFocus": { "alias": "completeOnFocus"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "completeMethod": "completeMethod"; "onSelect": "onSelect"; "onUnselect": "onUnselect"; "onDropdownClick": "onDropdownClick"; "onClear": "onClear"; "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; "onChange": "onChange"; }, never, never, true, never>;
+}
+
+type ColorFormat = 'hex' | 'rgb' | 'hsb';
+type ColorPickerChangeEvent = {
+    value: string;
+};
+declare class ColorPickerComponent implements ControlValueAccessor {
+    private readonly _el;
+    onDocumentClick(e: MouseEvent): void;
+    readonly format: _angular_core.InputSignal<ColorFormat>;
+    readonly inline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onChange: _angular_core.OutputEmitterRef<ColorPickerChangeEvent>;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<string>;
+    readonly hexInput: _angular_core.Signal<string>;
+    readonly presetColors: string[];
+    private _onChange;
+    private _onTouched;
+    togglePanel(): void;
+    selectPreset(color: string): void;
+    onHexInput(hex: string): void;
+    onNativeChange(color: string): void;
+    private _setValue;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPickerComponent, "f-colorpicker", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "onChange": "onChange"; }, never, never, true, never>;
+}
+
+interface ListboxChangeEvent {
+    originalEvent: Event;
+    value: unknown;
+}
+declare class ListboxComponent implements ControlValueAccessor {
+    readonly options: _angular_core.InputSignal<unknown[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly listStyle: _angular_core.InputSignal<Record<string, string> | null>;
+    readonly metaKeySelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly emptyFilterMessage: _angular_core.InputSignal<string>;
+    readonly onChange: _angular_core.OutputEmitterRef<ListboxChangeEvent>;
+    private readonly _filterText;
+    readonly filterText: _angular_core.Signal<string>;
+    private readonly _value;
+    private _onChange;
+    private _onTouched;
+    readonly filteredOptions: _angular_core.Signal<Record<string, unknown>[]>;
+    onFilterInput(e: Event): void;
+    clearFilter(): void;
+    getOptionLabel(opt: unknown): string;
+    getOptionValue(opt: unknown): unknown;
+    isSelected(opt: unknown): boolean;
+    optionClass(opt: unknown): string;
+    onOptionClick(e: Event, opt: unknown): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListboxComponent, "f-listbox", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "listStyle": { "alias": "listStyle"; "required": false; "isSignal": true; }; "metaKeySelection": { "alias": "metaKeySelection"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyFilterMessage": { "alias": "emptyFilterMessage"; "required": false; "isSignal": true; }; }, { "onChange": "onChange"; }, never, never, true, never>;
+}
+
+declare class SplitButtonComponent {
+    private readonly _el;
+    onDocumentClick(e: MouseEvent): void;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly severity: _angular_core.InputSignal<ButtonSeverity>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly raised: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly outlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly text: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly iconPos: _angular_core.InputSignal<"left" | "right">;
+    readonly size: _angular_core.InputSignal<"small" | "large" | null>;
+    readonly menuStyleClass: _angular_core.InputSignal<string>;
+    readonly appendTo: _angular_core.InputSignal<string>;
+    readonly onClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly onDropdownClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    readonly dropdownClass: _angular_core.Signal<string>;
+    toggleMenu(e: MouseEvent): void;
+    onItemClick(e: Event, item: MenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplitButtonComponent, "f-splitbutton", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "raised": { "alias": "raised"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "outlined": { "alias": "outlined"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "iconPos": { "alias": "iconPos"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "menuStyleClass": { "alias": "menuStyleClass"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; "onDropdownClick": "onDropdownClick"; }, never, never, true, never>;
+}
+
+interface TreeNode<T = unknown> {
+    data?: T;
+    children?: TreeNode<T>[];
+    expanded?: boolean;
+    leaf?: boolean;
+    label?: string;
+    icon?: string;
+    expandedIcon?: string;
+    collapsedIcon?: string;
+    key?: string;
+    type?: string;
+    selectable?: boolean;
+    partialSelected?: boolean;
+    styleClass?: string;
+    draggable?: boolean;
+    droppable?: boolean;
+    parent?: TreeNode<T>;
+    [key: string]: unknown;
+}
+
+interface TreeTableNode<T = unknown> {
+    node: TreeNode<T>;
+    level: number;
+    leaf: boolean;
+    expanded: boolean;
+    visible: boolean;
+}
+declare class TreeTableService {
+    private readonly _expanded;
+    readonly expanded: _angular_core.Signal<ReadonlySet<string>>;
+    toggle(key: string, node: TreeNode): void;
+    isExpanded(key: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeTableService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TreeTableService>;
+}
+declare class TreeTableTogglerComponent {
+    readonly rowNode: _angular_core.InputSignal<TreeTableNode<unknown>>;
+    private readonly svc;
+    onToggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeTableTogglerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeTableTogglerComponent, "f-treetabletoggler", never, { "rowNode": { "alias": "rowNode"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class TreeTableComponent {
+    readonly value: _angular_core.InputSignal<TreeNode<unknown>[]>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dataKey: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly tableStyle: _angular_core.InputSignal<Record<string, string> | null>;
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly bodyTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly emptyTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    private readonly svc;
+    readonly flatRows: _angular_core.Signal<TreeTableNode<unknown>[]>;
+    trackByRow(_idx: number, row: TreeTableNode): unknown;
+    private _flatten;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeTableComponent, "f-treetable", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "dataKey": { "alias": "dataKey"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "tableStyle": { "alias": "tableStyle"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; }, {}, ["headerTemplate", "bodyTemplate", "emptyTemplate"], never, true, never>;
+}
+
+type TreeSelectionMode$1 = 'single' | 'multiple' | 'checkbox';
+interface FlatTreeSelectNode {
+    node: TreeNode;
+    key: string;
+    level: number;
+    leaf: boolean;
+    visible: boolean;
+}
+declare class TreeSelectComponent implements ControlValueAccessor {
+    private readonly _el;
+    readonly options: _angular_core.InputSignal<TreeNode<unknown>[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectionMode: _angular_core.InputSignal<TreeSelectionMode$1>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private readonly _filterText;
+    readonly filterText: _angular_core.Signal<string>;
+    private readonly _selectedKeys;
+    readonly selectedKeys: _angular_core.Signal<Set<string>>;
+    private readonly expandedKeys;
+    private _onChange;
+    private _onTouched;
+    private _keyToNode;
+    readonly triggerClass: _angular_core.Signal<string>;
+    readonly flatNodes: _angular_core.Signal<FlatTreeSelectNode[]>;
+    readonly selectedLabels: _angular_core.Signal<string[]>;
+    private _flatten;
+    onDocumentClick(e: MouseEvent): void;
+    onFilterInput(v: string): void;
+    toggleOpen(): void;
+    toggleExpand(e: Event, key: string): void;
+    isExpanded(key: string): boolean;
+    isSelected(key: string): boolean;
+    isPartial(key: string): boolean;
+    onNodeClick(e: Event, row: FlatTreeSelectNode): void;
+    private toggleMultiple;
+    private toggleCheckbox;
+    private setDescendantSelection;
+    findKeyByLabel(label: string): string;
+    removeByKey(e: Event, key: string): void;
+    private emitChange;
+    writeValue(v: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeSelectComponent, "f-treeselect", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UiIconComponent {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly spin: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly fill: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly lucideName: _angular_core.Signal<string>;
+    readonly iconClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiIconComponent, "ui-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "spin": { "alias": "spin"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type BadgeSeverity = 'success' | 'info' | 'warn' | 'danger' | 'secondary' | 'contrast' | null;
+type BadgeSize = 'small' | 'large' | 'xlarge' | null;
+declare class BadgeComponent {
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly severity: _angular_core.InputSignal<BadgeSeverity>;
+    readonly size: _angular_core.InputSignal<BadgeSize>;
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeComponent, "f-badge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class OverlayBadgeComponent {
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly severity: _angular_core.InputSignal<BadgeSeverity>;
+    readonly size: _angular_core.InputSignal<BadgeSize>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayBadgeComponent, "f-overlaybadge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FieldsetComponent {
+    readonly legend: _angular_core.InputSignal<string>;
+    readonly toggleable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapsed: _angular_core.ModelSignal<boolean>;
+    toggleCollapsed(): void;
+    onSpace(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldsetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldsetComponent, "f-fieldset", never, { "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+type FloatLabelVariant = 'over' | 'in' | 'on';
+declare class FloatLabelComponent {
+    readonly variant: _angular_core.InputSignal<FloatLabelVariant>;
+    readonly hostClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FloatLabelComponent, "f-floatlabel", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class IftaLabelComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IftaLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IftaLabelComponent, "f-iftalabel", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ButtonGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroupComponent, "f-buttongroup", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class InputGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputGroupComponent, "f-inputgroup", never, {}, {}, never, ["*"], true, never>;
+}
+declare class InputGroupAddonComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputGroupAddonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputGroupAddonComponent, "f-inputgroupaddon", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollTopComponent {
+    private readonly el;
+    private readonly platformId;
+    readonly threshold: _angular_core.InputSignal<number>;
+    readonly behavior: _angular_core.InputSignal<ScrollBehavior>;
+    readonly target: _angular_core.InputSignal<"parent" | "window">;
+    readonly buttonAriaLabel: _angular_core.InputSignal<string>;
+    private readonly _visible;
+    readonly visible: _angular_core.Signal<boolean>;
+    constructor();
+    private getScrollElement;
+    private getScrollTop;
+    onScroll(): void;
+    scrollToTop(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollTopComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollTopComponent, "f-scrolltop", never, { "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "behavior": { "alias": "behavior"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "buttonAriaLabel": { "alias": "buttonAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface MeterItem {
+    label: string;
+    value: number;
+    color?: string;
+    icon?: string;
+}
+declare class MeterGroupComponent {
+    readonly values: _angular_core.InputSignal<MeterItem[]>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    percent(value: number): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeterGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeterGroupComponent, "f-metergroup", never, { "values": { "alias": "values"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FluidComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FluidComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FluidComponent, "f-fluid", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class BlockUiComponent {
+    readonly blocked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hasCustomTemplate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockUiComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockUiComponent, "f-blockui", never, { "blocked": { "alias": "blocked"; "required": false; "isSignal": true; }; "hasCustomTemplate": { "alias": "hasCustomTemplate"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[block-template]"], true, never>;
+}
+
+declare class MenuComponent {
+    private readonly _el;
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly popup: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _visible;
+    readonly visible: _angular_core.Signal<boolean>;
+    private _openedAt;
+    toggle(event?: Event): void;
+    show(event?: Event): void;
+    hide(): void;
+    onDocumentClick(e: MouseEvent): void;
+    onItemClick(e: Event, item: MenuItem): void;
+    onKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "f-menu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "popup": { "alias": "popup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MenubarComponent {
+    private readonly _el;
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    private readonly _activeRoot;
+    readonly activeRoot: _angular_core.Signal<MenuItem | null>;
+    private readonly _activeSubItem;
+    readonly activeSubItem: _angular_core.Signal<MenuItem | null>;
+    onRootEnter(item: MenuItem): void;
+    onRootLeave(item: MenuItem): void;
+    onRootClick(e: Event, item: MenuItem): void;
+    onSubEnter(item: MenuItem): void;
+    onSubLeave(item: MenuItem): void;
+    onItemClick(e: Event, item: MenuItem): void;
+    onDocumentClick(e: MouseEvent): void;
+    onRootKeydown(e: KeyboardEvent): void;
+    onSubmenuKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenubarComponent, "f-menubar", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TieredMenuComponent {
+    private readonly _el;
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly popup: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _visible;
+    readonly visible: _angular_core.Signal<boolean>;
+    private readonly _activeItem;
+    readonly activeItem: _angular_core.Signal<MenuItem | null>;
+    private _openedAt;
+    toggle(event?: Event): void;
+    show(event?: Event): void;
+    hide(): void;
+    onEnter(item: MenuItem): void;
+    onLeave(item: MenuItem): void;
+    onDocumentClick(e: MouseEvent): void;
+    onItemClick(e: Event, item: MenuItem): void;
+    onArrowRight(e: Event, item: MenuItem): void;
+    onArrowLeft(e: Event): void;
+    onKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TieredMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TieredMenuComponent, "f-tieredmenu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "popup": { "alias": "popup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ContextMenuComponent {
+    private readonly _el;
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly target: _angular_core.InputSignal<string>;
+    private readonly _visible;
+    readonly visible: _angular_core.Signal<boolean>;
+    private readonly _x;
+    readonly x: _angular_core.Signal<number>;
+    private readonly _y;
+    readonly y: _angular_core.Signal<number>;
+    show(event: MouseEvent): void;
+    hide(): void;
+    onDocumentContextMenu(e: MouseEvent): void;
+    onDocumentClick(e: MouseEvent): void;
+    onItemClick(e: Event, item: MenuItem): void;
+    onKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContextMenuComponent, "f-contextmenu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MegaMenuComponent {
+    private readonly _el;
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    private readonly _activeItem;
+    readonly activeItem: _angular_core.Signal<MenuItem | null>;
+    onRootClick(e: Event, item: MenuItem): void;
+    onLeafClick(e: Event, item: MenuItem): void;
+    onDocumentClick(e: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MegaMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MegaMenuComponent, "f-megamenu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PanelMenuComponent {
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    private readonly expanded;
+    private _seeded;
+    constructor();
+    isExpanded(item: MenuItem): boolean;
+    onItemClick(e: Event, item: MenuItem): void;
+    onKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PanelMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PanelMenuComponent, "f-panelmenu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbComponent {
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly home: _angular_core.InputSignal<MenuItem | null>;
+    onItemClick(e: Event, item: MenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbComponent, "f-breadcrumb", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "home": { "alias": "home"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SpeedDialDirection = 'up' | 'down' | 'left' | 'right';
+type SpeedDialType = 'linear' | 'circle';
+declare class SpeedDialComponent {
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly direction: _angular_core.InputSignal<SpeedDialDirection>;
+    readonly rotate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly type: _angular_core.InputSignal<SpeedDialType>;
+    readonly radius: _angular_core.InputSignal<number>;
+    private readonly _visible;
+    readonly visible: _angular_core.Signal<boolean>;
+    private readonly _el;
+    onDocumentClick(e: MouseEvent): void;
+    readonly containerClass: _angular_core.Signal<string>;
+    itemStyle(i: number): Record<string, string>;
+    toggle(): void;
+    onItemClick(e: Event, item: MenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpeedDialComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpeedDialComponent, "f-speeddial", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "rotate": { "alias": "rotate"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type DockPosition = 'bottom' | 'top' | 'left' | 'right';
+declare class DockComponent {
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly position: _angular_core.InputSignal<DockPosition>;
+    private readonly _hovered;
+    readonly hovered: _angular_core.Signal<MenuItem | null>;
+    readonly containerClass: _angular_core.Signal<string>;
+    readonly originClass: _angular_core.Signal<string>;
+    onHover(item: MenuItem | null): void;
+    onItemClick(e: Event, item: MenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DockComponent, "f-dock", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InputMaskDirective implements ControlValueAccessor {
+    private readonly _el;
+    readonly fInputMask: _angular_core.InputSignal<string>;
+    readonly slotChar: _angular_core.InputSignal<string>;
+    private _onChange;
+    private _onTouched;
+    onInput(e: Event): void;
+    onBlur(): void;
+    private format;
+    private unmask;
+    writeValue(v: string): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputMaskDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputMaskDirective, "[fInputMask]", never, { "fInputMask": { "alias": "fInputMask"; "required": false; "isSignal": true; }; "slotChar": { "alias": "slotChar"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InputTextDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InputOtpComponent implements ControlValueAccessor {
+    readonly length: _angular_core.InputSignal<number>;
+    readonly mask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly integerOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly cells: _angular_core.Signal<readonly ElementRef<HTMLInputElement>[]>;
+    readonly cellClass: _angular_core.Signal<string>;
+    private readonly _digits;
+    readonly digits: _angular_core.Signal<string[]>;
+    private _onChange;
+    private _onTouched;
+    indices(): number[];
+    onDigitInput(e: Event, i: number): void;
+    onKeydown(e: KeyboardEvent, i: number): void;
+    onPaste(e: ClipboardEvent): void;
+    private emitValue;
+    writeValue(v: string): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputOtpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputOtpComponent, "f-inputotp", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "integerOnly": { "alias": "integerOnly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SliderComponent implements ControlValueAccessor {
+    private readonly _el;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly range: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _start;
+    readonly start: _angular_core.Signal<number>;
+    private readonly _end;
+    readonly end: _angular_core.Signal<number>;
+    private _onChange;
+    private _onTouched;
+    private _dragIdx;
+    readonly startPercent: _angular_core.Signal<number>;
+    readonly endPercent: _angular_core.Signal<number>;
+    readonly rangeStartPercent: _angular_core.Signal<number>;
+    readonly rangePercent: _angular_core.Signal<number>;
+    private toPercent;
+    private fromClientX;
+    onTrackDown(e: MouseEvent): void;
+    onHandleDown(e: MouseEvent, idx: 0 | 1): void;
+    onHandleTouchStart(e: TouchEvent, idx: 0 | 1): void;
+    onKeydown(e: KeyboardEvent, idx: 0 | 1): void;
+    private startDrag;
+    private startTouchDrag;
+    private setValue;
+    writeValue(v: number | [number, number] | null): void;
+    registerOnChange(fn: (v: number | [number, number]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "f-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KnobComponent implements ControlValueAccessor {
+    private readonly _el;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly strokeWidth: _angular_core.InputSignal<number>;
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly valueColor: _angular_core.InputSignal<string>;
+    readonly rangeColor: _angular_core.InputSignal<string>;
+    readonly textColor: _angular_core.InputSignal<string>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<number>;
+    private _onChange;
+    private _onTouched;
+    readonly radius: _angular_core.Signal<number>;
+    readonly circumference: _angular_core.Signal<number>;
+    readonly dashOffset: _angular_core.Signal<number>;
+    onKeydown(e: KeyboardEvent): void;
+    onDown(e: MouseEvent): void;
+    private updateFromEvent;
+    writeValue(v: number): void;
+    registerOnChange(fn: (v: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KnobComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KnobComponent, "f-knob", never, { "size": { "alias": "size"; "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; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "valueColor": { "alias": "valueColor"; "required": false; "isSignal": true; }; "rangeColor": { "alias": "rangeColor"; "required": false; "isSignal": true; }; "textColor": { "alias": "textColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface CascadeOption {
+    [key: string]: unknown;
+}
+declare class CascadeSelectComponent implements ControlValueAccessor {
+    private readonly _el;
+    readonly options: _angular_core.InputSignal<CascadeOption[]>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<string>;
+    readonly optionChildren: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    private readonly _open;
+    readonly open: _angular_core.Signal<boolean>;
+    private readonly _activePath;
+    readonly activePath: _angular_core.Signal<CascadeOption[]>;
+    private readonly _selectedPath;
+    readonly selectedPath: _angular_core.Signal<string[]>;
+    private _onChange;
+    private _onTouched;
+    private _selectedValue;
+    readonly triggerClass: _angular_core.Signal<string>;
+    readonly levels: _angular_core.Signal<CascadeOption[][]>;
+    getLabel(opt: CascadeOption): string;
+    getValue(opt: CascadeOption): unknown;
+    getChildren(opt: CascadeOption): CascadeOption[];
+    isActive(opt: CascadeOption, level: number): boolean;
+    toggleOpen(): void;
+    onOptionClick(opt: CascadeOption, level: number): void;
+    onDocumentClick(e: MouseEvent): void;
+    writeValue(v: unknown): void;
+    private findPath;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CascadeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CascadeSelectComponent, "f-cascadeselect", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionChildren": { "alias": "optionChildren"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type KeyFilterPreset = 'int' | 'pint' | 'num' | 'pnum' | 'money' | 'alpha' | 'alphanum' | 'email';
+declare class KeyFilterDirective {
+    readonly fKeyFilter: _angular_core.InputSignal<RegExp | KeyFilterPreset | null>;
+    onKeypress(e: KeyboardEvent): void;
+    onPaste(e: ClipboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyFilterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KeyFilterDirective, "[fKeyFilter]", never, { "fKeyFilter": { "alias": "fKeyFilter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ConfirmPopupComponent {
+    readonly confirmationService: ConfirmationService;
+    readonly key: _angular_core.InputSignal<string | undefined>;
+    private readonly _top;
+    readonly top: _angular_core.Signal<number>;
+    private readonly _left;
+    readonly left: _angular_core.Signal<number>;
+    private readonly panelRef;
+    private readonly acceptBtnRef;
+    readonly activeConfirmation: _angular_core.Signal<UiConfirmation | null>;
+    constructor();
+    private position;
+    private adjustForViewport;
+    onEscape(): void;
+    accept(fn?: () => void): void;
+    reject(fn?: () => void): void;
+    onDocumentClick(e: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmPopupComponent, "f-confirmpopup", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DynamicDialogConfig<T = unknown> {
+    header?: string;
+    width?: string;
+    height?: string;
+    closable?: boolean;
+    closeOnEscape?: boolean;
+    dismissableMask?: boolean;
+    footer?: Type<unknown>;
+    data?: T;
+}
+declare class DynamicDialogRef<R = unknown> {
+    private readonly _closeFn;
+    private readonly _onClose;
+    readonly onClose: rxjs.Observable<R | undefined>;
+    constructor(_closeFn: (result?: R) => void);
+    close(result?: R): void;
+}
+declare const DYNAMIC_DIALOG_DATA: InjectionToken<unknown>;
+declare const DYNAMIC_DIALOG_REF: InjectionToken<DynamicDialogRef<unknown>>;
+interface DynamicDialogState {
+    id: number;
+    component: Type<unknown>;
+    config: DynamicDialogConfig;
+    ref: DynamicDialogRef<unknown>;
+}
+declare class DynamicDialogService {
+    private static idCounter;
+    private readonly _states;
+    readonly states: _angular_core.Signal<DynamicDialogState[]>;
+    open<T = unknown, R = unknown>(component: Type<T>, config?: DynamicDialogConfig): DynamicDialogRef<R>;
+    closeTop(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DynamicDialogService>;
+}
+
+declare class DynamicDialogComponent {
+    readonly dialogService: DynamicDialogService;
+    private readonly _parentInjector;
+    private readonly injectorCache;
+    constructor();
+    childInjector(state: DynamicDialogState): Injector;
+    readonly topState: _angular_core.Signal<DynamicDialogState>;
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicDialogComponent, "f-dynamicdialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class InplaceComponent {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly active: _angular_core.ModelSignal<boolean>;
+    readonly onActivate: _angular_core.OutputEmitterRef<void>;
+    readonly onDeactivate: _angular_core.OutputEmitterRef<void>;
+    open(): void;
+    close(): void;
+    onSpace(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InplaceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InplaceComponent, "f-inplace", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; "onActivate": "onActivate"; "onDeactivate": "onDeactivate"; }, never, ["[fInplaceDisplay]", "[fInplaceContent]"], true, never>;
+}
+
+type TreeSelectionMode = 'single' | 'multiple' | 'checkbox' | null;
+interface FlatNode {
+    node: TreeNode;
+    key: string;
+    level: number;
+    leaf: boolean;
+}
+declare class TreeComponent {
+    readonly value: _angular_core.InputSignal<TreeNode<unknown>[]>;
+    readonly selectionMode: _angular_core.InputSignal<TreeSelectionMode>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<TreeNode<unknown>[]>;
+    readonly nodeExpand: _angular_core.OutputEmitterRef<TreeNode<unknown>>;
+    readonly nodeCollapse: _angular_core.OutputEmitterRef<TreeNode<unknown>>;
+    private readonly _filterText;
+    readonly filterText: _angular_core.Signal<string>;
+    private readonly _selectedKeys;
+    readonly selectedKeys: _angular_core.Signal<Set<string>>;
+    private readonly expandedKeys;
+    private _keyToNode;
+    readonly flatNodes: _angular_core.Signal<FlatNode[]>;
+    private _flatten;
+    onFilterInput(v: string): void;
+    isExpanded(key: string): boolean;
+    isSelected(key: string): boolean;
+    isPartial(key: string): boolean;
+    toggleExpand(e: Event, key: string): void;
+    onNodeClick(row: FlatNode): void;
+    private setDescendants;
+    private emitSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeComponent, "f-tree", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; }, never, never, true, never>;
+}
+
+type TimelineAlign = 'left' | 'right' | 'alternate';
+type TimelineLayout = 'vertical' | 'horizontal';
+declare class TimelineComponent<T = unknown> {
+    readonly value: _angular_core.InputSignal<T[]>;
+    readonly align: _angular_core.InputSignal<TimelineAlign>;
+    readonly layout: _angular_core.InputSignal<TimelineLayout>;
+    readonly contentTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineComponent<any>, "f-timeline", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, {}, ["contentTpl"], never, true, never>;
+}
+
+type DataViewLayout = 'list' | 'grid';
+declare class DataViewComponent<T = unknown> {
+    readonly value: _angular_core.InputSignal<T[]>;
+    readonly showLayoutToggle: _angular_core.InputSignal<boolean>;
+    readonly paginator: _angular_core.InputSignal<boolean>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly totalRecords: _angular_core.InputSignal<number>;
+    readonly first: _angular_core.InputSignal<number>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly layout: _angular_core.ModelSignal<DataViewLayout>;
+    readonly onPageChange: _angular_core.OutputEmitterRef<PaginatorState>;
+    readonly itemTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    handlePageChange(event: PaginatorState): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataViewComponent<any>, "f-dataview", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "showLayoutToggle": { "alias": "showLayoutToggle"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "totalRecords": { "alias": "totalRecords"; "required": false; "isSignal": true; }; "first": { "alias": "first"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, { "layout": "layoutChange"; "onPageChange": "onPageChange"; }, ["itemTpl"], never, true, never>;
+}
+
+declare class CarouselComponent<T = unknown> implements OnDestroy {
+    readonly value: _angular_core.InputSignal<T[]>;
+    readonly numVisible: _angular_core.InputSignal<number>;
+    readonly showIndicators: _angular_core.InputSignal<boolean>;
+    readonly circular: _angular_core.InputSignal<boolean>;
+    readonly autoplayInterval: _angular_core.InputSignal<number>;
+    readonly onPage: _angular_core.OutputEmitterRef<number>;
+    readonly itemTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly destroyRef;
+    private autoplayTimer;
+    private readonly _page;
+    readonly page: _angular_core.Signal<number>;
+    readonly pageCount: _angular_core.Signal<number>;
+    readonly pageIndices: _angular_core.Signal<number[]>;
+    constructor();
+    pageItems(page: number): T[];
+    private setPage;
+    prev(): void;
+    next(): void;
+    goToPage(i: number): void;
+    private startAutoplay;
+    private stopAutoplay;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CarouselComponent<any>, "f-carousel", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "numVisible": { "alias": "numVisible"; "required": false; "isSignal": true; }; "showIndicators": { "alias": "showIndicators"; "required": false; "isSignal": true; }; "circular": { "alias": "circular"; "required": false; "isSignal": true; }; "autoplayInterval": { "alias": "autoplayInterval"; "required": false; "isSignal": true; }; }, { "onPage": "onPage"; }, ["itemTpl"], never, true, never>;
+}
+
+declare class ScrollPanelComponent {
+    readonly maxHeight: _angular_core.InputSignal<string>;
+    readonly maxWidth: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollPanelComponent, "f-scrollpanel", never, { "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollerComponent<T = unknown> implements AfterViewInit, OnDestroy {
+    readonly items: _angular_core.InputSignal<T[]>;
+    readonly itemSize: _angular_core.InputSignal<number>;
+    readonly scrollHeight: _angular_core.InputSignal<string>;
+    readonly itemTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly viewportRef;
+    private readonly destroyRef;
+    private resizeObserver;
+    private readonly scrollTop;
+    private readonly viewportHeight;
+    readonly totalHeight: _angular_core.Signal<number>;
+    readonly startIndex: _angular_core.Signal<number>;
+    private readonly endIndex;
+    readonly visibleItems: _angular_core.Signal<T[]>;
+    offsetFor(relativeIndex: number): number;
+    onScroll(e: Event): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollerComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollerComponent<any>, "f-scroller", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; }, {}, ["itemTpl"], never, true, never>;
+}
+
+declare class OrganizationChartComponent {
+    readonly value: _angular_core.InputSignal<TreeNode<unknown> | null>;
+    readonly contentTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrganizationChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrganizationChartComponent, "f-organizationchart", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, ["contentTpl"], never, true, never>;
+}
+
+declare class PickListComponent<T = unknown> {
+    readonly source: _angular_core.ModelSignal<T[]>;
+    readonly target: _angular_core.ModelSignal<T[]>;
+    readonly sourceHeader: _angular_core.InputSignal<string>;
+    readonly targetHeader: _angular_core.InputSignal<string>;
+    readonly itemTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly _sourceSelected;
+    readonly sourceSelected: _angular_core.Signal<Set<T>>;
+    private readonly _targetSelected;
+    readonly targetSelected: _angular_core.Signal<Set<T>>;
+    readonly onMoveToTarget: _angular_core.OutputEmitterRef<T[]>;
+    readonly onMoveToSource: _angular_core.OutputEmitterRef<T[]>;
+    private toggleSelect;
+    toggleSourceSelect(item: T): void;
+    toggleTargetSelect(item: T): void;
+    moveToTarget(): void;
+    moveAllToTarget(): void;
+    moveToSource(): void;
+    moveAllToSource(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PickListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PickListComponent<any>, "f-picklist", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "sourceHeader": { "alias": "sourceHeader"; "required": false; "isSignal": true; }; "targetHeader": { "alias": "targetHeader"; "required": false; "isSignal": true; }; }, { "source": "sourceChange"; "target": "targetChange"; "onMoveToTarget": "onMoveToTarget"; "onMoveToSource": "onMoveToSource"; }, ["itemTpl"], never, true, never>;
+}
+
+declare class OrderListComponent<T = unknown> {
+    readonly value: _angular_core.ModelSignal<T[]>;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly itemTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly selected: _angular_core.ModelSignal<T | null>;
+    readonly onReorder: _angular_core.OutputEmitterRef<T[]>;
+    private swap;
+    moveUp(): void;
+    moveDown(): void;
+    moveTop(): void;
+    moveBottom(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrderListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrderListComponent<any>, "f-orderlist", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selected": "selectedChange"; "onReorder": "onReorder"; }, ["itemTpl"], never, true, never>;
+}
+
+interface GalleriaItem {
+    itemImageSrc: string;
+    thumbnailImageSrc?: string;
+    alt?: string;
+}
+declare class GalleriaComponent {
+    readonly value: _angular_core.InputSignal<GalleriaItem[]>;
+    readonly showThumbnails: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly height: _angular_core.InputSignal<string>;
+    private readonly _activeIndex;
+    readonly activeIndex: _angular_core.Signal<number>;
+    prev(): void;
+    next(): void;
+    selectIndex(i: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GalleriaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GalleriaComponent, "f-galleria", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "showThumbnails": { "alias": "showThumbnails"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface EditorCommand {
+    cmd: string;
+    icon: string;
+    label: string;
+    value?: string;
+}
+declare class EditorComponent implements ControlValueAccessor {
+    private readonly _document;
+    private readonly _sanitizer;
+    readonly editable: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly toolbar: EditorCommand[];
+    private _onChange;
+    private _onTouched;
+    exec(btn: EditorCommand): void;
+    onInput(): void;
+    onTouched(): void;
+    writeValue(v: string): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorComponent, "f-editor", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TerminalCommandEvent {
+    command: string;
+}
+declare class TerminalComponent {
+    readonly welcomeMessage: _angular_core.InputSignal<string>;
+    readonly prompt: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly onCommand: _angular_core.OutputEmitterRef<TerminalCommandEvent>;
+    private readonly _current;
+    readonly current: _angular_core.Signal<string>;
+    private readonly _history;
+    readonly history: _angular_core.Signal<{
+        type: "command" | "response";
+        text: string;
+    }[]>;
+    onCurrentInput(v: string): void;
+    submit(): void;
+    respond(text: string): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TerminalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TerminalComponent, "f-terminal", never, { "welcomeMessage": { "alias": "welcomeMessage"; "required": false; "isSignal": true; }; "prompt": { "alias": "prompt"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "onCommand": "onCommand"; }, never, never, true, never>;
+}
+
+declare class ImageCompareComponent {
+    private readonly _el;
+    private readonly destroyRef;
+    readonly imageBeforeSrc: _angular_core.InputSignal<string>;
+    readonly imageAfterSrc: _angular_core.InputSignal<string>;
+    readonly altBefore: _angular_core.InputSignal<string>;
+    readonly altAfter: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    private readonly _position;
+    readonly position: _angular_core.Signal<number>;
+    private readonly _containerWidth;
+    readonly containerWidth: _angular_core.Signal<string>;
+    private activeCleanup;
+    constructor();
+    onDown(e: MouseEvent): void;
+    onTouchDown(e: TouchEvent): void;
+    private updatePosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageCompareComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageCompareComponent, "f-imagecompare", never, { "imageBeforeSrc": { "alias": "imageBeforeSrc"; "required": false; "isSignal": true; }; "imageAfterSrc": { "alias": "imageAfterSrc"; "required": false; "isSignal": true; }; "altBefore": { "alias": "altBefore"; "required": false; "isSignal": true; }; "altAfter": { "alias": "altAfter"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AnimateOnScrollDirective implements AfterViewInit, OnDestroy {
+    private readonly _el;
+    private readonly _platformId;
+    readonly enterClass: _angular_core.InputSignal<string>;
+    readonly leaveClass: _angular_core.InputSignal<string>;
+    readonly once: _angular_core.InputSignal<boolean>;
+    readonly threshold: _angular_core.InputSignal<number>;
+    private _observer?;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimateOnScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AnimateOnScrollDirective, "[fAnimateOnScroll]", never, { "enterClass": { "alias": "enterClass"; "required": false; "isSignal": true; }; "leaveClass": { "alias": "leaveClass"; "required": false; "isSignal": true; }; "once": { "alias": "once"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AutoFocusDirective implements AfterViewInit {
+    private readonly _el;
+    readonly fAutoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoFocusDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AutoFocusDirective, "[fAutoFocus]", never, { "fAutoFocus": { "alias": "fAutoFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RippleDirective {
+    private readonly _el;
+    onMouseDown(e: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RippleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RippleDirective, "[fRipple]", never, {}, {}, never, never, true, never>;
+}
+
+declare class UiModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<UiModule, never, [typeof i1.FormsModule, typeof ConfirmDialog, typeof ToastComponent, typeof AvatarComponent, typeof AvatarGroupComponent, typeof ButtonComponent, typeof FButtonDirective, typeof ChipComponent, typeof DividerComponent, typeof ImageComponent, typeof MessageComponent, typeof ProgressbarComponent, typeof ProgressSpinnerComponent, typeof SkeletonComponent, typeof TagComponent, typeof CheckboxComponent, typeof DatePickerComponent, typeof FileUploadComponent, typeof IconFieldComponent, typeof InputIconComponent, typeof InputNumberComponent, typeof InputTextDirective, typeof InputPasswordDirective, typeof MultiSelectComponent, typeof PasswordComponent, typeof RadioButtonComponent, typeof RatingComponent, typeof SelectComponent, typeof SelectButtonComponent, typeof TextareaDirective, typeof ToggleButtonComponent, typeof ToggleSwitchComponent, typeof DialogComponent, typeof DrawerComponent, typeof PopoverComponent, typeof CardComponent, typeof PanelComponent, typeof StepsComponent, typeof SplitterComponent, typeof SplitterPanelComponent, typeof ToolbarComponent, typeof TabsComponent, typeof TabComponent, typeof TabListComponent, typeof TabPanelComponent, typeof TabPanelsComponent, typeof AccordionComponent, typeof AccordionPanelComponent, typeof AccordionHeaderComponent, typeof AccordionContentComponent, typeof ChartComponent, typeof PaginatorComponent, typeof SortIconComponent, typeof SortableColumnDirective, typeof StyleClassDirective, typeof TableComponent, typeof TooltipDirective, typeof AutoCompleteComponent, typeof ColorPickerComponent, typeof ListboxComponent, typeof SplitButtonComponent, typeof TreeTableComponent, typeof TreeTableTogglerComponent, typeof TreeSelectComponent, typeof UiIconComponent, typeof BadgeComponent, typeof OverlayBadgeComponent, typeof FieldsetComponent, typeof FloatLabelComponent, typeof IftaLabelComponent, typeof ButtonGroupComponent, typeof InputGroupComponent, typeof InputGroupAddonComponent, typeof ScrollTopComponent, typeof MeterGroupComponent, typeof FluidComponent, typeof BlockUiComponent, typeof MenuComponent, typeof MenubarComponent, typeof TieredMenuComponent, typeof ContextMenuComponent, typeof MegaMenuComponent, typeof PanelMenuComponent, typeof BreadcrumbComponent, typeof SpeedDialComponent, typeof DockComponent, typeof InputMaskDirective, typeof InputOtpComponent, typeof SliderComponent, typeof KnobComponent, typeof CascadeSelectComponent, typeof KeyFilterDirective, typeof ConfirmPopupComponent, typeof DynamicDialogComponent, typeof InplaceComponent, typeof TreeComponent, typeof TimelineComponent, typeof DataViewComponent, typeof CarouselComponent, typeof ScrollPanelComponent, typeof ScrollerComponent, typeof OrganizationChartComponent, typeof PickListComponent, typeof OrderListComponent, typeof GalleriaComponent, typeof EditorComponent, typeof TerminalComponent, typeof ImageCompareComponent, typeof AnimateOnScrollDirective, typeof AutoFocusDirective, typeof RippleDirective, typeof FTemplateDirective], [typeof ConfirmDialog, typeof ToastComponent, typeof AvatarComponent, typeof AvatarGroupComponent, typeof ButtonComponent, typeof FButtonDirective, typeof ChipComponent, typeof DividerComponent, typeof ImageComponent, typeof MessageComponent, typeof ProgressbarComponent, typeof ProgressSpinnerComponent, typeof SkeletonComponent, typeof TagComponent, typeof CheckboxComponent, typeof DatePickerComponent, typeof FileUploadComponent, typeof IconFieldComponent, typeof InputIconComponent, typeof InputNumberComponent, typeof InputTextDirective, typeof InputPasswordDirective, typeof MultiSelectComponent, typeof PasswordComponent, typeof RadioButtonComponent, typeof RatingComponent, typeof SelectComponent, typeof SelectButtonComponent, typeof TextareaDirective, typeof ToggleButtonComponent, typeof ToggleSwitchComponent, typeof DialogComponent, typeof DrawerComponent, typeof PopoverComponent, typeof CardComponent, typeof PanelComponent, typeof StepsComponent, typeof SplitterComponent, typeof SplitterPanelComponent, typeof ToolbarComponent, typeof TabsComponent, typeof TabComponent, typeof TabListComponent, typeof TabPanelComponent, typeof TabPanelsComponent, typeof AccordionComponent, typeof AccordionPanelComponent, typeof AccordionHeaderComponent, typeof AccordionContentComponent, typeof ChartComponent, typeof PaginatorComponent, typeof SortIconComponent, typeof SortableColumnDirective, typeof StyleClassDirective, typeof TableComponent, typeof TooltipDirective, typeof AutoCompleteComponent, typeof ColorPickerComponent, typeof ListboxComponent, typeof SplitButtonComponent, typeof TreeTableComponent, typeof TreeTableTogglerComponent, typeof TreeSelectComponent, typeof UiIconComponent, typeof BadgeComponent, typeof OverlayBadgeComponent, typeof FieldsetComponent, typeof FloatLabelComponent, typeof IftaLabelComponent, typeof ButtonGroupComponent, typeof InputGroupComponent, typeof InputGroupAddonComponent, typeof ScrollTopComponent, typeof MeterGroupComponent, typeof FluidComponent, typeof BlockUiComponent, typeof MenuComponent, typeof MenubarComponent, typeof TieredMenuComponent, typeof ContextMenuComponent, typeof MegaMenuComponent, typeof PanelMenuComponent, typeof BreadcrumbComponent, typeof SpeedDialComponent, typeof DockComponent, typeof InputMaskDirective, typeof InputOtpComponent, typeof SliderComponent, typeof KnobComponent, typeof CascadeSelectComponent, typeof KeyFilterDirective, typeof ConfirmPopupComponent, typeof DynamicDialogComponent, typeof InplaceComponent, typeof TreeComponent, typeof TimelineComponent, typeof DataViewComponent, typeof CarouselComponent, typeof ScrollPanelComponent, typeof ScrollerComponent, typeof OrganizationChartComponent, typeof PickListComponent, typeof OrderListComponent, typeof GalleriaComponent, typeof EditorComponent, typeof TerminalComponent, typeof ImageCompareComponent, typeof AnimateOnScrollDirective, typeof AutoFocusDirective, typeof RippleDirective, typeof FTemplateDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<UiModule>;
+}
+
+interface NgUITranslationConfig {
+    accept?: string;
+    reject?: string;
+    choose?: string;
+    upload?: string;
+    cancel?: string;
+    close?: string;
+    clear?: string;
+    apply?: string;
+    remove?: string;
+    today?: string;
+    weekHeader?: string;
+    firstDayOfWeek?: number;
+    showMonthAfterYear?: boolean;
+    dateFormat?: string;
+    dayNames?: string[];
+    dayNamesShort?: string[];
+    dayNamesMin?: string[];
+    monthNames?: string[];
+    monthNamesShort?: string[];
+    aria?: Record<string, string>;
+    [key: string]: unknown;
+}
+interface NgUIOptions {
+    theme?: {
+        options?: {
+            darkModeSelector?: string;
+            cssLayer?: {
+                name: string;
+                order: string;
+            } | false;
+        };
+    };
+    translation?: NgUITranslationConfig;
+}
+declare class NgUIConfig {
+    private readonly _translation;
+    readonly translation: _angular_core.Signal<NgUITranslationConfig>;
+    configure(options: NgUIOptions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgUIConfig, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgUIConfig>;
+}
+
+type ColorShade = '50' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900' | '950';
+type ColorPalette = Record<ColorShade, string>;
+type SurfacePalette = {
+    0: string;
+} & ColorPalette;
+declare const PRIMARY_PALETTES: Record<string, ColorPalette>;
+declare const SURFACE_PALETTES: Record<string, SurfacePalette>;
+declare const NOIR_PRIMARY: ColorPalette;
+
+type PresetName = 'Aura' | 'Lara' | 'Nora';
+interface SelectButtonTokens {
+    background: string;
+    borderColor: string;
+    dividerColor: string;
+    padding: string;
+    itemColor: string;
+    itemHoverBackground: string;
+    checkedBackground: string;
+    checkedColor: string;
+    checkedShadow: string;
+    fontWeight: string;
+    itemBorderRadius: string;
+}
+interface ThemePreset {
+    name: PresetName;
+    borderRadius: string;
+    borderRadiusSm: string;
+    borderRadiusLg: string;
+    borderRadiusXl: string;
+    borderWidth: string;
+    shadowSm: string;
+    shadow: string;
+    shadowLg: string;
+    shadowXl: string;
+    shadow2xl: string;
+    transitionDuration: string;
+    focusRingWidth: string;
+    focusRingStyle: string;
+    focusRingOffset: string;
+    buttonFontWeight: string;
+    highlightVariant: 'tint' | 'solid';
+    strongBorders: boolean;
+    selectButton: SelectButtonTokens;
+    cardBorderRadius: string;
+    cardPadding: string;
+    cardGap: string;
+    cardShadow: string;
+}
+declare const AURA_PRESET: ThemePreset;
+declare const NORA_PRESET: ThemePreset;
+declare const LARA_PRESET: ThemePreset;
+declare const PRESETS: Record<PresetName, ThemePreset>;
+declare const PRESET_NAMES: PresetName[];
+
+declare function applyPrimaryPalette(palette: ColorPalette, isDark?: boolean, root?: HTMLElement): void;
+declare function applySurfacePalette(palette: SurfacePalette, root?: HTMLElement): void;
+declare function applyLightSemantics(root?: HTMLElement): void;
+declare function applyDarkSemantics(root?: HTMLElement): void;
+declare function applyPreset(preset: ThemePreset, root?: HTMLElement): void;
+interface ApplyThemeOptions {
+    preset?: PresetName;
+    primary?: string;
+    surface?: string | null;
+    darkTheme?: boolean;
+}
+declare function applyTheme(options: ApplyThemeOptions, root?: HTMLElement): void;
+declare function buildBootstrapPreset(envConfig?: {
+    preset?: string;
+    primary?: string;
+    surface?: string | null;
+    isMemorable?: boolean;
+}): ApplyThemeOptions;
+
+interface ProvideNgUIOptions {
+    theme?: {
+        preset?: ApplyThemeOptions | {
+            preset: ApplyThemeOptions;
+            options: {
+                darkModeSelector?: string;
+            };
+        };
+        options?: {
+            darkModeSelector?: string;
+        };
+    };
+    translation?: NgUIOptions['translation'];
+    ripple?: boolean;
+}
+declare function provideNgUI(options?: ProvideNgUIOptions): EnvironmentProviders;
+
+declare class TabsContext {
+    private readonly _active;
+    readonly active: _angular_core.Signal<string | number>;
+    private readonly _scrollable;
+    readonly scrollable: _angular_core.Signal<boolean>;
+    setActive(v: string | number): void;
+    setScrollable(v: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TabsContext>;
+}
+
+export { AURA_PRESET, AccordionComponent, AccordionContentComponent, AccordionContext, AccordionHeaderComponent, AccordionPanelComponent, AnimateOnScrollDirective, AutoCompleteComponent, AutoFocusDirective, AvatarComponent, AvatarGroupComponent, BadgeComponent, BlockUiComponent, BreadcrumbComponent, ButtonComponent, ButtonGroupComponent, CardComponent, CarouselComponent, CascadeSelectComponent, ChartComponent, CheckboxComponent, ChipComponent, ColorPickerComponent, ConfirmDialog, ConfirmPopupComponent, ConfirmationService, ContextMenuComponent, DYNAMIC_DIALOG_DATA, DYNAMIC_DIALOG_REF, DataViewComponent, DatePickerComponent, DialogComponent, DividerComponent, DockComponent, DrawerComponent, DynamicDialogComponent, DynamicDialogRef, DynamicDialogService, EditorComponent, FButtonDirective, FTemplateDirective, FieldsetComponent, FileUploadComponent, FloatLabelComponent, FluidComponent, GalleriaComponent, IconFieldComponent, IftaLabelComponent, ImageCompareComponent, ImageComponent, InplaceComponent, InputGroupAddonComponent, InputGroupComponent, InputIconComponent, InputMaskDirective, InputNumberComponent, InputOtpComponent, InputPasswordDirective, InputTextDirective, KeyFilterDirective, KnobComponent, LARA_PRESET, ListboxComponent, MegaMenuComponent, MenuComponent, MenubarComponent, MessageComponent, MessageService, MeterGroupComponent, MultiSelectComponent, NOIR_PRIMARY, NORA_PRESET, NgUIConfig, OrderListComponent, OrganizationChartComponent, OverlayBadgeComponent, PRESETS, PRESET_NAMES, PRIMARY_PALETTES, PaginatorComponent, PanelComponent, PanelMenuComponent, PasswordComponent, PickListComponent, PopoverComponent, ProgressSpinnerComponent, ProgressbarComponent, RadioButtonComponent, RatingComponent, RippleDirective, SURFACE_PALETTES, ScrollPanelComponent, ScrollTopComponent, ScrollerComponent, SelectButtonComponent, SelectComponent, SkeletonComponent, SliderComponent, SortIconComponent, SortableColumnDirective, SpeedDialComponent, SplitButtonComponent, SplitterComponent, SplitterPanelComponent, StepsComponent, StyleClassDirective, TabComponent, TabListComponent, TabPanelComponent, TabPanelsComponent, TableComponent, TabsComponent, TabsContext, TagComponent, TerminalComponent, TextareaDirective, TieredMenuComponent, TimelineComponent, ToastComponent, ToggleButtonComponent, ToggleSwitchComponent, ToolbarComponent, TooltipDirective, TreeComponent, TreeSelectComponent, TreeTableComponent, TreeTableService, TreeTableTogglerComponent, UiIconComponent, UiModule, applyDarkSemantics, applyLightSemantics, applyPreset, applyPrimaryPalette, applySurfacePalette, applyTheme, buildBootstrapPreset, provideNgUI };
+export type { ApplyThemeOptions, AutoCompleteCompleteEvent, AutoCompleteSelectEvent, BadgeSeverity, BadgeSize, ButtonSeverity, CheckboxChangeEvent, ColorFormat, ColorPalette, ColorPickerChangeEvent, DataViewLayout, DynamicDialogConfig, FileRemoveEvent, FileSelectEvent, FloatLabelVariant, GalleriaItem, KeyFilterPreset, ListboxChangeEvent, MenuItem, MenuItemCommandEvent, MeterItem, NgUIOptions, NgUITranslationConfig, PaginatorState, PresetName, ProvideNgUIOptions, RadioButtonClickEvent, SelectButtonTokens, SpeedDialDirection, SpeedDialType, StepsMenuItem, SurfacePalette, TableLazyLoadEvent, TerminalCommandEvent, ThemePreset, TimelineAlign, TimelineLayout, TreeSelectionMode as TreeComponentSelectionMode, TreeNode, TreeSelectionMode$1 as TreeSelectionMode, TreeTableNode, UiMessage };