@enelar-esp/ui 0.1.0

package/types/enelar-esp-ui.d.ts

@@ -0,0 +1,1460 @@
+import * as _angular_core from '@angular/core';
+import { AfterContentInit, OnDestroy, ElementRef, OnInit, EventEmitter, TemplateRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as _enelar_esp_ui from '@enelar-esp/ui';
+
+declare const ColorTokens: {
+    readonly primary: {
+        readonly 50: "#f0fdf4";
+        readonly 100: "#dcfce7";
+        readonly 200: "#bbf7d0";
+        readonly 300: "#86efac";
+        readonly 400: "#4ade80";
+        readonly 500: "#22c55e";
+        readonly 600: "#16a34a";
+        readonly 700: "#15803d";
+        readonly 800: "#166534";
+        readonly 900: "#14532d";
+        readonly 950: "#052e16";
+    };
+    readonly secondary: {
+        readonly 50: "#f8fafc";
+        readonly 100: "#f1f5f9";
+        readonly 200: "#e2e8f0";
+        readonly 300: "#cbd5e1";
+        readonly 400: "#94a3b8";
+        readonly 500: "#64748b";
+        readonly 600: "#475569";
+        readonly 700: "#334155";
+        readonly 800: "#1e293b";
+        readonly 900: "#0f172a";
+        readonly 950: "#020617";
+    };
+    readonly neutral: {
+        readonly 50: "#fafafa";
+        readonly 100: "#f4f4f5";
+        readonly 200: "#e4e4e7";
+        readonly 300: "#d4d4d8";
+        readonly 400: "#a1a1aa";
+        readonly 500: "#71717a";
+        readonly 600: "#52525b";
+        readonly 700: "#3f3f46";
+        readonly 800: "#27272a";
+        readonly 900: "#18181b";
+        readonly 950: "#09090b";
+    };
+    readonly semantic: {
+        readonly success: {
+            readonly light: "#bbf7d0";
+            readonly main: "#22c55e";
+            readonly dark: "#15803d";
+        };
+        readonly warning: {
+            readonly light: "#fef08a";
+            readonly main: "#eab308";
+            readonly dark: "#a16207";
+        };
+        readonly error: {
+            readonly light: "#fecaca";
+            readonly main: "#ef4444";
+            readonly dark: "#b91c1c";
+        };
+        readonly info: {
+            readonly light: "#bfdbfe";
+            readonly main: "#3b82f6";
+            readonly dark: "#1d4ed8";
+        };
+    };
+};
+declare const SpacingTokens: {
+    readonly xs: "4px";
+    readonly sm: "8px";
+    readonly md: "16px";
+    readonly lg: "24px";
+    readonly xl: "32px";
+    readonly '2xl': "48px";
+    readonly '3xl': "64px";
+};
+declare const TypographyTokens: {
+    readonly fontFamily: {
+        readonly sans: "Inter, system-ui, -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif";
+        readonly mono: "SFMono-Regular, Menlo, Monaco, Consolas, \"Liberation Mono\", \"Courier New\", monospace";
+    };
+    readonly fontSize: {
+        readonly xs: "0.75rem";
+        readonly sm: "0.875rem";
+        readonly base: "1rem";
+        readonly lg: "1.125rem";
+        readonly xl: "1.25rem";
+        readonly '2xl': "1.5rem";
+        readonly '3xl': "1.875rem";
+        readonly '4xl': "2.25rem";
+    };
+    readonly fontWeight: {
+        readonly light: "300";
+        readonly regular: "400";
+        readonly medium: "500";
+        readonly semibold: "600";
+        readonly bold: "700";
+    };
+    readonly lineHeight: {
+        readonly none: "1";
+        readonly tight: "1.25";
+        readonly snug: "1.375";
+        readonly normal: "1.5";
+        readonly relaxed: "1.625";
+        readonly loose: "2";
+    };
+};
+declare const BorderTokens: {
+    readonly radius: {
+        readonly none: "0px";
+        readonly sm: "4px";
+        readonly md: "8px";
+        readonly lg: "12px";
+        readonly xl: "16px";
+        readonly full: "9999px";
+    };
+    readonly width: {
+        readonly none: "0px";
+        readonly sm: "1px";
+        readonly md: "2px";
+        readonly lg: "4px";
+    };
+};
+declare const ShadowTokens: {
+    readonly sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)";
+    readonly md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)";
+    readonly lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)";
+    readonly xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)";
+    readonly inner: "inset 0 2px 4px 0 rgba(0, 0, 0, 0.05)";
+};
+declare const ZIndexTokens: {
+    readonly hide: -1;
+    readonly auto: "auto";
+    readonly base: 0;
+    readonly docked: 10;
+    readonly dropdown: 1000;
+    readonly sticky: 1100;
+    readonly banner: 1200;
+    readonly overlay: 1300;
+    readonly modal: 1400;
+    readonly popover: 1500;
+    readonly skipLink: 1600;
+    readonly toast: 1700;
+    readonly tooltip: 1800;
+};
+declare const AnimationTokens: {
+    readonly duration: {
+        readonly fastest: "50ms";
+        readonly fast: "150ms";
+        readonly normal: "200ms";
+        readonly slow: "300ms";
+        readonly slowest: "400ms";
+    };
+    readonly easing: {
+        readonly linear: "linear";
+        readonly easeIn: "cubic-bezier(0.4, 0, 1, 1)";
+        readonly easeOut: "cubic-bezier(0, 0, 0.2, 1)";
+        readonly easeInOut: "cubic-bezier(0.4, 0, 0.2, 1)";
+    };
+};
+declare const BreakpointTokens: {
+    readonly xs: "320px";
+    readonly sm: "640px";
+    readonly md: "768px";
+    readonly lg: "1024px";
+    readonly xl: "1280px";
+    readonly '2xl': "1536px";
+};
+
+type EnlTheme = 'light' | 'dark';
+declare class EnlThemeService {
+    private readonly STORAGE_KEY;
+    private readonly activeThemeSignal;
+    readonly activeTheme: _angular_core.Signal<EnlTheme>;
+    readonly isDark: _angular_core.Signal<boolean>;
+    readonly isLight: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Directly sets a specific theme.
+     * @param theme The theme to set.
+     */
+    setTheme(theme: EnlTheme): void;
+    /**
+     * Toggles the active theme between light and dark.
+     */
+    toggleTheme(): void;
+    /**
+     * Inits the theme setting based on storage or user browser defaults.
+     */
+    private initializeTheme;
+    /**
+     * Applies the theme attribute to the HTML document tag.
+     */
+    private applyThemeToDocument;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EnlThemeService>;
+}
+
+type ToastType = 'success' | 'error' | 'warning' | 'info';
+interface Toast {
+    id: number;
+    message: string;
+    type: ToastType;
+}
+declare class EnlToastService {
+    private readonly toastsSignal;
+    readonly toasts: _angular_core.Signal<Toast[]>;
+    private seq;
+    show(message: string, type?: ToastType, duration?: number): number;
+    success(message: string, duration?: number): number;
+    error(message: string, duration?: number): number;
+    warning(message: string, duration?: number): number;
+    info(message: string, duration?: number): number;
+    remove(id: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EnlToastService>;
+}
+
+type TypographyVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'body' | 'body-sm' | 'caption' | 'code';
+type TypographyAlign = 'left' | 'center' | 'right' | 'justify';
+type TypographyWeight = 'light' | 'regular' | 'medium' | 'semibold' | 'bold';
+type TypographyColor = 'primary' | 'secondary' | 'muted' | 'success' | 'warning' | 'danger' | 'info' | 'inherit';
+type TypographyElement = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'span' | 'div';
+
+declare class EnlTypographyComponent {
+    readonly variant: _angular_core.InputSignal<TypographyVariant>;
+    readonly align: _angular_core.InputSignal<TypographyAlign>;
+    readonly weight: _angular_core.InputSignal<TypographyWeight | undefined>;
+    readonly color: _angular_core.InputSignal<TypographyColor>;
+    readonly element: _angular_core.InputSignal<TypographyElement | undefined>;
+    readonly htmlTag: _angular_core.Signal<TypographyElement>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlTypographyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlTypographyComponent, "enl-typography", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "element": { "alias": "element"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface ITypographyProps {
+    variant?: TypographyVariant;
+    align?: TypographyAlign;
+    weight?: TypographyWeight;
+    color?: TypographyColor;
+    element?: TypographyElement;
+}
+
+type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type SpinnerVariant = 'primary' | 'secondary' | 'neutral' | 'inverse';
+
+declare class EnlSpinnerComponent {
+    readonly size: _angular_core.InputSignal<SpinnerSize>;
+    readonly variant: _angular_core.InputSignal<SpinnerVariant>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlSpinnerComponent, "enl-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ISpinnerProps {
+    size?: SpinnerSize;
+    variant?: SpinnerVariant;
+    ariaLabel?: string;
+}
+
+type IconName = 'search' | 'close' | 'check' | 'chevron-down' | 'chevron-up' | 'chevron-right' | 'chevron-left' | 'menu' | 'user' | 'lock' | 'info' | 'success' | 'warning' | 'error' | 'settings' | 'logout' | 'arrow-right' | 'mail' | 'avatar' | 'sun' | 'moon' | 'eye' | 'eye-off' | 'calendar';
+type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'inherit';
+
+declare class EnlIconComponent {
+    readonly name: _angular_core.InputSignal<IconName>;
+    readonly size: _angular_core.InputSignal<IconSize>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly paths: _angular_core.Signal<string[]>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlIconComponent, "enl-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface IIconProps {
+    name: IconName;
+    size?: IconSize;
+    color?: string;
+    ariaLabel?: string;
+}
+
+declare const IconPaths: Record<IconName, string[]>;
+
+type ButtonVariant = 'primary' | 'secondary' | 'success' | 'info' | 'warn' | 'help' | 'danger' | 'contrast' | 'ghost' | 'link';
+type ButtonSize = 'sm' | 'md' | 'lg';
+type ButtonState = 'idle' | 'loading' | 'disabled';
+
+declare class EnlButtonComponent {
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
+    readonly size: _angular_core.InputSignal<ButtonSize>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    readonly iconLeft: _angular_core.InputSignal<IconName | undefined>;
+    readonly iconRight: _angular_core.InputSignal<IconName | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly iconOnly: _angular_core.InputSignal<boolean>;
+    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    /**
+     * Safe click handler preventing events when disabled.
+     */
+    handleClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlButtonComponent, "enl-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "iconLeft": { "alias": "iconLeft"; "required": false; "isSignal": true; }; "iconRight": { "alias": "iconRight"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+}
+
+interface IButtonProps {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    disabled?: boolean;
+    loading?: boolean;
+    type?: 'button' | 'submit' | 'reset';
+    iconLeft?: IconName;
+    iconRight?: IconName;
+    ariaLabel?: string;
+}
+
+declare class EnlLabelComponent {
+    readonly for: _angular_core.InputSignal<string | undefined>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlLabelComponent, "enl-label", never, { "for": { "alias": "for"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface ILabelProps {
+    htmlFor?: string;
+    required?: boolean;
+    disabled?: boolean;
+}
+
+type InputType = 'text' | 'password' | 'email' | 'number' | 'tel' | 'url' | 'date';
+type InputSize = 'sm' | 'md' | 'lg';
+
+declare class EnlInputComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly type: _angular_core.InputSignal<InputType>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<InputSize>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    private readonly formField;
+    private readonly generatedId;
+    readonly inputId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly innerValue: _angular_core.WritableSignal<string>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleInput(event: Event): void;
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlInputComponent, "enl-input", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface IInputProps {
+    id?: string;
+    type?: InputType;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    size?: InputSize;
+    error?: boolean;
+}
+
+type BadgeVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
+type BadgeSize = 'sm' | 'md';
+type BadgeShape = 'pill' | 'square';
+
+declare class EnlBadgeComponent {
+    readonly variant: _angular_core.InputSignal<BadgeVariant>;
+    readonly size: _angular_core.InputSignal<BadgeSize>;
+    readonly shape: _angular_core.InputSignal<BadgeShape>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlBadgeComponent, "enl-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface IBadgeProps {
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    shape?: BadgeShape;
+}
+
+declare class EnlCheckboxComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    protected readonly innerChecked: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleChange(event: Event): void;
+    protected handleBlur(): void;
+    readonly computedLabelClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlCheckboxComponent, "enl-checkbox", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface ICheckboxProps {
+    id?: string;
+    name?: string;
+    checked?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    error?: boolean;
+}
+
+declare class EnlRadioComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    protected readonly innerChecked: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleChange(event: Event): void;
+    protected handleBlur(): void;
+    readonly computedLabelClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlRadioComponent, "enl-radio", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface IRadioProps {
+    id?: string;
+    name?: string;
+    value?: unknown;
+    checked?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    error?: boolean;
+}
+
+type AvatarSize = 'sm' | 'md' | 'lg' | 'xl';
+type AvatarShape = 'circle' | 'square';
+
+declare class EnlAvatarComponent {
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly initials: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<AvatarSize>;
+    readonly shape: _angular_core.InputSignal<AvatarShape>;
+    readonly backgroundColor: _angular_core.InputSignal<string | undefined>;
+    protected readonly imageError: _angular_core.WritableSignal<boolean>;
+    readonly showInitials: _angular_core.Signal<boolean>;
+    protected handleImageError(): void;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlAvatarComponent, "enl-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "initials": { "alias": "initials"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface IAvatarProps {
+    src?: string;
+    alt?: string;
+    initials?: string;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+}
+
+declare class EnlSelectComponent implements ControlValueAccessor, AfterContentInit, OnDestroy {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly showSelectedIcon: _angular_core.InputSignal<boolean>;
+    nativeSelect: ElementRef<HTMLSelectElement>;
+    searchInput?: ElementRef<HTMLInputElement>;
+    private readonly elementRef;
+    private readonly formField;
+    private readonly generatedId;
+    readonly selectId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly innerValue: _angular_core.WritableSignal<string>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly parsedOptions: _angular_core.WritableSignal<{
+        value: string;
+        label: string;
+    }[]>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly activeOptionIndex: _angular_core.WritableSignal<number>;
+    protected readonly searchQuery: _angular_core.WritableSignal<string>;
+    protected readonly filteredOptions: _angular_core.Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    private observer?;
+    private onChangeFn?;
+    private onTouchedFn?;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onDocumentClick(event: MouseEvent): void;
+    private parseNativeOptions;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected selectOption(value: string, event?: Event): void;
+    private focusSearchInput;
+    protected toggleDropdown(event: MouseEvent): void;
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    protected clearSelection(event: MouseEvent): void;
+    protected onSearchInput(event: Event): void;
+    protected clearSearch(event: MouseEvent): void;
+    protected handleSearchKeydown(event: KeyboardEvent): void;
+    readonly computedTriggerClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlSelectComponent, "enl-select", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "showSelectedIcon": { "alias": "showSelectedIcon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class EnlInputNumberComponent implements ControlValueAccessor, OnInit {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly showButtons: _angular_core.InputSignal<boolean>;
+    readonly buttonLayout: _angular_core.InputSignal<"stacked" | "horizontal">;
+    readonly format: _angular_core.InputSignal<boolean>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly mode: _angular_core.InputSignal<"decimal" | "currency">;
+    readonly currency: _angular_core.InputSignal<string | undefined>;
+    readonly minFractionDigits: _angular_core.InputSignal<number>;
+    readonly maxFractionDigits: _angular_core.InputSignal<number>;
+    readonly prefix: _angular_core.InputSignal<string | undefined>;
+    readonly suffix: _angular_core.InputSignal<string | undefined>;
+    readonly valueChange: EventEmitter<number | null>;
+    readonly focusEvent: EventEmitter<FocusEvent>;
+    readonly blurEvent: EventEmitter<FocusEvent>;
+    private readonly formField;
+    private readonly generatedId;
+    readonly inputId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly val: _angular_core.WritableSignal<number | null>;
+    protected readonly inputValue: _angular_core.WritableSignal<string>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    constructor();
+    ngOnInit(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleInput(event: Event): void;
+    protected handleFocus(event: FocusEvent): void;
+    protected handleBlur(event: FocusEvent): void;
+    protected handleKeyDown(event: KeyboardEvent): void;
+    protected increment(): void;
+    protected decrement(): void;
+    private emitChange;
+    private getDecimalSeparator;
+    private getGroupSeparator;
+    private getRawEditValue;
+    private getFormattedValue;
+    private parseValue;
+    private clampValue;
+    readonly computedWrapperClasses: _angular_core.Signal<string>;
+    readonly computedInputClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlInputNumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlInputNumberComponent, "enl-input-number", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "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; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "buttonLayout": { "alias": "buttonLayout"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "minFractionDigits": { "alias": "minFractionDigits"; "required": false; "isSignal": true; }; "maxFractionDigits": { "alias": "maxFractionDigits"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; }, never, never, true, never>;
+}
+
+declare class EnlInputOtpComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly length: _angular_core.InputSignal<number>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly integerOnly: _angular_core.InputSignal<boolean>;
+    readonly mask: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly otpChange: EventEmitter<string>;
+    readonly complete: EventEmitter<string>;
+    private readonly formField;
+    private readonly generatedId;
+    readonly inputId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly cells: _angular_core.WritableSignal<string[]>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    private readonly cellInputs;
+    protected readonly cellIndices: _angular_core.Signal<number[]>;
+    constructor();
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleInput(event: Event, index: number): void;
+    protected handleKeyDown(event: KeyboardEvent, index: number): void;
+    protected handlePaste(event: ClipboardEvent, index: number): void;
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    private focusCell;
+    private emitChange;
+    readonly computedWrapperClasses: _angular_core.Signal<string>;
+    readonly computedCellClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlInputOtpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlInputOtpComponent, "enl-input-otp", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "integerOnly": { "alias": "integerOnly"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "otpChange": "otpChange"; "complete": "complete"; }, never, never, true, never>;
+}
+
+declare class EnlPasswordComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly toggleMask: _angular_core.InputSignal<boolean>;
+    readonly feedback: _angular_core.InputSignal<boolean>;
+    readonly promptLabel: _angular_core.InputSignal<string>;
+    readonly weakLabel: _angular_core.InputSignal<string>;
+    readonly mediumLabel: _angular_core.InputSignal<string>;
+    readonly strongLabel: _angular_core.InputSignal<string>;
+    readonly valueChange: EventEmitter<string>;
+    readonly focusEvent: EventEmitter<FocusEvent>;
+    readonly blurEvent: EventEmitter<FocusEvent>;
+    private readonly formField;
+    private readonly generatedId;
+    readonly inputId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly innerValue: _angular_core.WritableSignal<string>;
+    protected readonly isMasked: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleInput(event: Event): void;
+    protected handleFocus(event: FocusEvent): void;
+    protected handleBlur(event: FocusEvent): void;
+    protected toggleVisibility(event: MouseEvent): void;
+    protected readonly strengthScore: _angular_core.Signal<number>;
+    protected readonly strengthLabel: _angular_core.Signal<string>;
+    protected readonly strengthClass: _angular_core.Signal<"enl-password__strength--empty" | "enl-password__strength--weak" | "enl-password__strength--medium" | "enl-password__strength--strong">;
+    readonly computedWrapperClasses: _angular_core.Signal<string>;
+    readonly computedInputClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlPasswordComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlPasswordComponent, "enl-password", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "toggleMask": { "alias": "toggleMask"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; "promptLabel": { "alias": "promptLabel"; "required": false; "isSignal": true; }; "weakLabel": { "alias": "weakLabel"; "required": false; "isSignal": true; }; "mediumLabel": { "alias": "mediumLabel"; "required": false; "isSignal": true; }; "strongLabel": { "alias": "strongLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; }, never, never, true, never>;
+}
+
+declare class EnlTextareaComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly cols: _angular_core.InputSignal<number | undefined>;
+    readonly maxlength: _angular_core.InputSignal<number | undefined>;
+    readonly counter: _angular_core.InputSignal<boolean>;
+    readonly autoResize: _angular_core.InputSignal<boolean>;
+    readonly valueChange: EventEmitter<string>;
+    readonly focusEvent: EventEmitter<FocusEvent>;
+    readonly blurEvent: EventEmitter<FocusEvent>;
+    textareaElement?: ElementRef<HTMLTextAreaElement>;
+    private readonly formField;
+    private readonly generatedId;
+    readonly textareaId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly innerValue: _angular_core.WritableSignal<string>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly currentLength: _angular_core.Signal<number>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleInput(event: Event): void;
+    protected handleFocus(event: FocusEvent): void;
+    protected handleBlur(event: FocusEvent): void;
+    private adjustHeight;
+    readonly computedWrapperClasses: _angular_core.Signal<string>;
+    readonly computedTextareaClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlTextareaComponent, "enl-textarea", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "counter": { "alias": "counter"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; }, never, never, true, never>;
+}
+
+declare class EnlToggleSwitchComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly labelPosition: _angular_core.InputSignal<"left" | "right">;
+    readonly valueChange: EventEmitter<boolean>;
+    readonly focusEvent: EventEmitter<FocusEvent>;
+    readonly blurEvent: EventEmitter<FocusEvent>;
+    private readonly formField;
+    private readonly generatedId;
+    readonly toggleId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly innerValue: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleChange(event: Event): void;
+    protected handleFocus(event: FocusEvent): void;
+    protected handleBlur(event: FocusEvent): void;
+    protected toggleState(event: Event): void;
+    readonly computedWrapperClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlToggleSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlToggleSwitchComponent, "enl-toggle-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; }, never, never, true, never>;
+}
+
+declare class EnlSkeletonComponent {
+    readonly shape: _angular_core.InputSignal<"circle" | "rectangle" | "line">;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly borderRadius: _angular_core.InputSignal<string | undefined>;
+    protected readonly computedClasses: _angular_core.Signal<string>;
+    protected readonly customBorderRadius: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlSkeletonComponent, "enl-skeleton", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EnlFormFieldComponent {
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<string | undefined>;
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    readonly customId: _angular_core.InputSignal<string | undefined>;
+    private readonly generatedId;
+    readonly id: _angular_core.Signal<string>;
+    readonly errorId: _angular_core.Signal<string>;
+    readonly hintId: _angular_core.Signal<string>;
+    protected projectedInput?: EnlInputComponent;
+    protected readonly ariaDescribedBy: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlFormFieldComponent, "enl-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "customId": { "alias": "customId"; "required": false; "isSignal": true; }; }, {}, ["projectedInput"], ["*"], true, never>;
+}
+
+declare class EnlSearchInputComponent implements ControlValueAccessor {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<InputSize>;
+    readonly buttonText: _angular_core.InputSignal<string | undefined>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly searchSubmitted: _angular_core.OutputEmitterRef<string>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    protected readonly innerValue: _angular_core.WritableSignal<string>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleInput(val: string): void;
+    protected handleKeyDown(event: KeyboardEvent): void;
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    protected handleClear(): void;
+    protected triggerSearch(): void;
+    protected readonly containerClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlSearchInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlSearchInputComponent, "enl-search-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "buttonText": { "alias": "buttonText"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "searchSubmitted": "searchSubmitted"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+interface CalendarDay {
+    date: Date;
+    dayNumber: number;
+    isCurrentMonth: boolean;
+    isSelected: boolean;
+    isToday: boolean;
+    isDisabled: boolean;
+    isRangeStart: boolean;
+    isRangeEnd: boolean;
+    isInRange: boolean;
+}
+declare class EnlDatePickerComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly minDate: _angular_core.InputSignal<string | undefined>;
+    readonly maxDate: _angular_core.InputSignal<string | undefined>;
+    readonly mode: _angular_core.InputSignal<"time" | "single" | "range" | "month">;
+    readonly showTime: _angular_core.InputSignal<boolean>;
+    readonly hourFormat: _angular_core.InputSignal<"12" | "24">;
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    readonly blockedDates: _angular_core.InputSignal<string[] | undefined>;
+    readonly disabledDatesFn: _angular_core.InputSignal<((date: Date) => boolean) | undefined>;
+    private readonly formField;
+    private readonly generatedId;
+    private readonly elementRef;
+    readonly inputId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    readonly computedPlaceholder: _angular_core.Signal<string>;
+    protected readonly selectedDate: _angular_core.WritableSignal<Date | null>;
+    protected readonly rangeStart: _angular_core.WritableSignal<Date | null>;
+    protected readonly rangeEnd: _angular_core.WritableSignal<Date | null>;
+    protected readonly hoveredDate: _angular_core.WritableSignal<Date | null>;
+    protected readonly selectedHour: _angular_core.WritableSignal<number>;
+    protected readonly selectedMinute: _angular_core.WritableSignal<number>;
+    protected readonly viewYear: _angular_core.WritableSignal<number>;
+    protected readonly viewMonth: _angular_core.WritableSignal<number>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    readonly monthNames: string[];
+    readonly dayNames: string[];
+    private onChangeFn?;
+    private onTouchedFn?;
+    readonly displayText: _angular_core.Signal<string>;
+    readonly calendarDays: _angular_core.Signal<CalendarDay[]>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    protected onDocumentClick(event: MouseEvent): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected toggleCalendar(): void;
+    protected selectDay(day: CalendarDay): void;
+    protected handleDayMouseEnter(date: Date): void;
+    protected isMonthSelected(monthIndex: number): boolean;
+    protected selectMonth(monthIndex: number): void;
+    protected adjustHour(amount: number): void;
+    protected adjustMinute(amount: number): void;
+    protected toggleAmPm(): void;
+    protected padTime(val: number): string;
+    protected confirmDateTime(): void;
+    protected confirmTimeOnly(): void;
+    private propagateTimeOnlyValue;
+    protected prevMonth(event: Event): void;
+    protected nextMonth(event: Event): void;
+    protected prevYear(event: Event): void;
+    protected nextYear(event: Event): void;
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    protected handleInputChange(event: Event): void;
+    private updateValue;
+    private propagateSingleValue;
+    private propagateRangeValue;
+    private propagateMonthValue;
+    private isSameDay;
+    private checkIsInRange;
+    private checkIsDayDisabled;
+    private isDateOutOfRange;
+    private zeroOutTime;
+    private parseISOString;
+    private parseMonthString;
+    private parseDateTimeString;
+    private parseTimeString;
+    /**
+     * Parses a formatted date string using the configured dateFormat pattern.
+     * Leverages any separator (like /, -, .) in the pattern to split and match
+     * year, month, and day elements correctly.
+     */
+    private parseVisualDateString;
+    /**
+     * Fallback parser for standard visual formats if the custom pattern split fails.
+     */
+    private parseDateFallback;
+    /**
+     * Formats a Date object into a string based on a given pattern (e.g. DD/MM/YYYY).
+     * Supports tokens: YYYY (4-digit year), YY (2-digit year), MM (2-digit month),
+     * DD (2-digit day), D (1 or 2-digit day), M (1 or 2-digit month).
+     */
+    private formatDateByPattern;
+    private formatDateToString;
+    private formatMonthToString;
+    private formatDateTimeToString;
+    private formatDateVisual;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlDatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlDatePickerComponent, "enl-date-picker", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "showTime": { "alias": "showTime"; "required": false; "isSignal": true; }; "hourFormat": { "alias": "hourFormat"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "blockedDates": { "alias": "blockedDates"; "required": false; "isSignal": true; }; "disabledDatesFn": { "alias": "disabledDatesFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EnlCardHeaderComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    readonly avatarSrc: _angular_core.InputSignal<string | undefined>;
+    readonly avatarInitials: _angular_core.InputSignal<string | undefined>;
+    readonly avatarShape: _angular_core.InputSignal<AvatarShape>;
+    readonly badgeText: _angular_core.InputSignal<string | undefined>;
+    readonly badgeVariant: _angular_core.InputSignal<BadgeVariant>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlCardHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlCardHeaderComponent, "enl-card-header", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "avatarSrc": { "alias": "avatarSrc"; "required": false; "isSignal": true; }; "avatarInitials": { "alias": "avatarInitials"; "required": false; "isSignal": true; }; "avatarShape": { "alias": "avatarShape"; "required": false; "isSignal": true; }; "badgeText": { "alias": "badgeText"; "required": false; "isSignal": true; }; "badgeVariant": { "alias": "badgeVariant"; "required": false; "isSignal": true; }; }, {}, never, ["[actions]"], true, never>;
+}
+
+declare class EnlCardComponent {
+    readonly shadow: _angular_core.InputSignal<"sm" | "md" | "lg" | "none">;
+    readonly bordered: _angular_core.InputSignal<boolean>;
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    readonly padding: _angular_core.InputSignal<"sm" | "md" | "lg" | "none">;
+    readonly cardClick: _angular_core.OutputEmitterRef<Event>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    protected onCardClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlCardComponent, "enl-card", never, { "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, { "cardClick": "cardClick"; }, never, ["enl-card-header, [header]", "*", "[footer]"], true, never>;
+}
+
+declare class EnlLoginFormFieldComponent implements ControlValueAccessor {
+    readonly type: _angular_core.InputSignal<"password" | "email">;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<string | undefined>;
+    protected readonly innerValue: _angular_core.WritableSignal<string>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly showPassword: _angular_core.WritableSignal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly currentInputType: _angular_core.Signal<"text" | "password" | "email">;
+    protected readonly generatedId: string;
+    private onChangeFn?;
+    private onTouchedFn?;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleInput(val: string): void;
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    protected togglePasswordVisibility(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlLoginFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlLoginFormFieldComponent, "enl-login-form-field", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EnlPaginatorComponent {
+    readonly currentPage: _angular_core.InputSignal<number>;
+    readonly totalPages: _angular_core.InputSignal<number>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly pageSizeOptions: _angular_core.InputSignal<number[] | readonly number[]>;
+    readonly totalItems: _angular_core.InputSignal<number>;
+    readonly pageChange: _angular_core.OutputEmitterRef<number>;
+    readonly pageSizeChange: _angular_core.OutputEmitterRef<number>;
+    readonly rangeStart: _angular_core.Signal<number>;
+    readonly rangeEnd: _angular_core.Signal<number>;
+    readonly pageNumbers: _angular_core.Signal<(number | "...")[]>;
+    goToPage(p: number | '...'): void;
+    onPageSizeSelect(value: string | number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlPaginatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlPaginatorComponent, "enl-paginator", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
+}
+
+declare class EnlStatCardComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<string | number>;
+    readonly variant: _angular_core.InputSignal<"success" | "primary" | "secondary" | "danger">;
+    readonly computedClasses: _angular_core.Signal<string>;
+    readonly valueClasses: _angular_core.Signal<string>;
+    readonly barClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlStatCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlStatCardComponent, "enl-stat-card", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EnlIconFieldComponent {
+    readonly iconPosition: _angular_core.InputSignal<"left" | "right" | "both">;
+    readonly computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlIconFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlIconFieldComponent, "enl-icon-field", never, { "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class EnlMultiSelectComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly options: _angular_core.InputSignal<any[]>;
+    readonly optionLabel: _angular_core.InputSignal<string | undefined>;
+    readonly optionValue: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly filter: _angular_core.InputSignal<boolean>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    readonly maxSelectedLabels: _angular_core.InputSignal<number>;
+    readonly selectedItemsLabel: _angular_core.InputSignal<string>;
+    readonly display: _angular_core.InputSignal<"comma" | "chip">;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly showHeader: _angular_core.InputSignal<boolean>;
+    readonly valueChange: EventEmitter<any[]>;
+    readonly panelShow: EventEmitter<void>;
+    readonly panelHide: EventEmitter<void>;
+    private readonly formField;
+    private readonly elementRef;
+    private readonly generatedId;
+    readonly inputId: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly selectedValues: _angular_core.WritableSignal<any[]>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    protected readonly isAccessorDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    private onChangeFn?;
+    private onTouchedFn?;
+    onDocumentClick(event: MouseEvent): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: any[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected togglePanel(): void;
+    protected openPanel(): void;
+    protected closePanel(): void;
+    protected getOptionLabel(option: any): string;
+    protected getOptionValue(option: any): any;
+    protected isSelected(option: any): boolean;
+    protected toggleOption(option: any, event?: Event): void;
+    protected toggleAll(event?: Event): void;
+    private emitChange;
+    protected readonly filteredOptions: _angular_core.Signal<any[]>;
+    protected readonly isAllSelected: _angular_core.Signal<boolean>;
+    protected readonly isPartiallySelected: _angular_core.Signal<boolean>;
+    protected readonly selectedOptions: _angular_core.Signal<{
+        label: string;
+        value: any;
+    }[]>;
+    protected readonly visibleChips: _angular_core.Signal<{
+        label: string;
+        value: any;
+    }[]>;
+    protected readonly extraChipsCount: _angular_core.Signal<number>;
+    protected readonly commaDisplayText: _angular_core.Signal<string>;
+    readonly computedWrapperClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlMultiSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlMultiSelectComponent, "enl-multi-select", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "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; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "maxSelectedLabels": { "alias": "maxSelectedLabels"; "required": false; "isSignal": true; }; "selectedItemsLabel": { "alias": "selectedItemsLabel"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "panelShow": "panelShow"; "panelHide": "panelHide"; }, never, never, true, never>;
+}
+
+declare class EnlPageHeaderComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlPageHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlPageHeaderComponent, "enl-page-header", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EnlSkeletonCardComponent {
+    readonly avatar: _angular_core.InputSignal<boolean>;
+    readonly lines: _angular_core.InputSignal<number>;
+    readonly cardBordered: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlSkeletonCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlSkeletonCardComponent, "enl-skeleton-card", never, { "avatar": { "alias": "avatar"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "cardBordered": { "alias": "cardBordered"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EnlNavbarComponent {
+    readonly brandTitle: _angular_core.InputSignal<string>;
+    readonly brandSubtitle: _angular_core.InputSignal<string | undefined>;
+    readonly userAvatarSrc: _angular_core.InputSignal<string | undefined>;
+    readonly userAvatarInitials: _angular_core.InputSignal<string>;
+    readonly showThemeToggle: _angular_core.InputSignal<boolean>;
+    readonly userProfileClick: _angular_core.OutputEmitterRef<void>;
+    readonly themeToggleClick: _angular_core.OutputEmitterRef<void>;
+    protected onUserProfileClick(): void;
+    protected onThemeToggleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlNavbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlNavbarComponent, "enl-navbar", never, { "brandTitle": { "alias": "brandTitle"; "required": true; "isSignal": true; }; "brandSubtitle": { "alias": "brandSubtitle"; "required": false; "isSignal": true; }; "userAvatarSrc": { "alias": "userAvatarSrc"; "required": false; "isSignal": true; }; "userAvatarInitials": { "alias": "userAvatarInitials"; "required": false; "isSignal": true; }; "showThemeToggle": { "alias": "showThemeToggle"; "required": false; "isSignal": true; }; }, { "userProfileClick": "userProfileClick"; "themeToggleClick": "themeToggleClick"; }, never, ["*", "[right-actions]"], true, never>;
+}
+
+declare class EnlSidebarComponent {
+    readonly collapsed: _angular_core.InputSignal<boolean>;
+    readonly brandTitle: _angular_core.InputSignal<string>;
+    readonly userEmail: _angular_core.InputSignal<string | undefined>;
+    readonly collapsedChange: _angular_core.OutputEmitterRef<boolean>;
+    protected toggleCollapse(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlSidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlSidebarComponent, "enl-sidebar", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "brandTitle": { "alias": "brandTitle"; "required": false; "isSignal": true; }; "userEmail": { "alias": "userEmail"; "required": false; "isSignal": true; }; }, { "collapsedChange": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+declare class EnlUserProfileCardComponent {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly email: _angular_core.InputSignal<string | undefined>;
+    readonly role: _angular_core.InputSignal<string | undefined>;
+    readonly avatarSrc: _angular_core.InputSignal<string | undefined>;
+    readonly avatarInitials: _angular_core.InputSignal<string>;
+    readonly status: _angular_core.InputSignal<"online" | "offline" | "away">;
+    readonly actionClick: _angular_core.OutputEmitterRef<string>;
+    protected readonly badgeVariant: _angular_core.Signal<BadgeVariant>;
+    protected readonly badgeLabel: _angular_core.Signal<string>;
+    protected triggerAction(action: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlUserProfileCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlUserProfileCardComponent, "enl-user-profile-card", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "email": { "alias": "email"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "avatarSrc": { "alias": "avatarSrc"; "required": false; "isSignal": true; }; "avatarInitials": { "alias": "avatarInitials"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, { "actionClick": "actionClick"; }, never, never, true, never>;
+}
+
+declare class EnlLoginPanelComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly subtitle: _angular_core.InputSignal<string>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly skeleton: _angular_core.InputSignal<boolean>;
+    readonly errorMessage: _angular_core.InputSignal<string | undefined>;
+    readonly loginSubmit: _angular_core.OutputEmitterRef<{
+        email: string;
+        password: string;
+    }>;
+    protected readonly emailValue: _angular_core.WritableSignal<string>;
+    protected readonly passwordValue: _angular_core.WritableSignal<string>;
+    protected readonly emailError: _angular_core.WritableSignal<string | undefined>;
+    protected readonly passwordError: _angular_core.WritableSignal<string | undefined>;
+    private readonly emailRegex;
+    protected readonly isFormValid: _angular_core.Signal<boolean>;
+    protected handleSubmit(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlLoginPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlLoginPanelComponent, "enl-login-panel", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "skeleton": { "alias": "skeleton"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; }, { "loginSubmit": "loginSubmit"; }, never, never, true, never>;
+}
+
+interface TableColumn {
+    key: string;
+    label: string;
+    sortable?: boolean;
+    type?: 'text' | 'badge' | 'avatar';
+}
+declare class EnlDataTableComponent {
+    readonly columns: _angular_core.InputSignal<TableColumn[]>;
+    readonly data: _angular_core.InputSignal<Record<string, unknown>[]>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly showSearch: _angular_core.InputSignal<boolean>;
+    protected readonly sortColumn: _angular_core.WritableSignal<string | null>;
+    protected readonly sortDirection: _angular_core.WritableSignal<"asc" | "desc">;
+    protected readonly currentPage: _angular_core.WritableSignal<number>;
+    protected readonly currentPageSize: _angular_core.WritableSignal<number>;
+    protected readonly searchQuery: _angular_core.WritableSignal<string>;
+    constructor();
+    protected readonly filteredData: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly sortedData: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly paginatedData: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly totalPages: _angular_core.Signal<number>;
+    protected handleSearchChange(query: string): void;
+    protected handleSort(col: TableColumn): void;
+    protected onPageSizeChange(size: number): void;
+    protected getAvatarData(value: unknown): {
+        src?: string;
+        initials: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlDataTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlDataTableComponent, "enl-data-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EnlModalComponent {
+    readonly show: _angular_core.InputSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly variant: _angular_core.InputSignal<"danger" | "default">;
+    readonly closeOnBackdrop: _angular_core.InputSignal<boolean>;
+    readonly showCloseButton: _angular_core.InputSignal<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    handleClose(): void;
+    handleBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlModalComponent, "enl-modal", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["[header-icon]", "*", "[footer]"], true, never>;
+}
+
+declare class EnlToastContainerComponent {
+    protected readonly toastService: EnlToastService;
+    protected readonly toasts: _angular_core.Signal<_enelar_esp_ui.Toast[]>;
+    removeToast(id: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlToastContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlToastContainerComponent, "enl-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+interface FormFieldConfig {
+    key: string;
+    type: 'text' | 'email' | 'password' | 'number' | 'select' | 'checkbox' | 'radio' | 'textarea' | 'toggle' | 'date';
+    label: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    hint?: string;
+    options?: {
+        value: string | number | boolean;
+        label: string;
+    }[];
+    min?: number;
+    max?: number;
+    gridClass?: string;
+}
+
+declare class EnlDynamicFormComponent {
+    readonly schema: _angular_core.InputSignal<FormFieldConfig[]>;
+    readonly value: _angular_core.ModelSignal<Record<string, unknown>>;
+    readonly errors: _angular_core.InputSignal<Record<string, string>>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly submitLabel: _angular_core.InputSignal<string>;
+    readonly cancelLabel: _angular_core.InputSignal<string>;
+    readonly showActions: _angular_core.InputSignal<boolean>;
+    readonly formSubmit: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    readonly formCancel: _angular_core.OutputEmitterRef<void>;
+    readonly valueChange: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    protected handleValueChange(key: string, val: unknown): void;
+    protected onSubmit(event: Event): void;
+    protected onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlDynamicFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlDynamicFormComponent, "enl-dynamic-form", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "submitLabel": { "alias": "submitLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "showActions": { "alias": "showActions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "formSubmit": "formSubmit"; "formCancel": "formCancel"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class EnlColumnTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    readonly columnName: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlColumnTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EnlColumnTemplateDirective, "[enlColumnTemplate]", never, { "columnName": { "alias": "enlColumnTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DynamicTableHeader {
+    text: string;
+    value: string;
+    sortable?: boolean;
+}
+declare class EnlDynamicTableComponent {
+    readonly itemsTable: _angular_core.InputSignal<Record<string, unknown>[]>;
+    readonly headerTable: _angular_core.InputSignal<DynamicTableHeader[]>;
+    readonly selectData: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly skeletonRows: _angular_core.InputSignal<number>;
+    readonly paginator: _angular_core.InputSignal<boolean>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly selectedDataChange: _angular_core.OutputEmitterRef<Record<string, unknown>[]>;
+    readonly selectedItems: _angular_core.WritableSignal<Record<string, unknown>[]>;
+    readonly sortColumn: _angular_core.WritableSignal<string | null>;
+    readonly sortDirection: _angular_core.WritableSignal<"asc" | "desc">;
+    readonly currentPage: _angular_core.WritableSignal<number>;
+    readonly currentPageSize: _angular_core.WritableSignal<number>;
+    readonly columnTemplates: _angular_core.Signal<readonly EnlColumnTemplateDirective[]>;
+    readonly defaultTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    constructor();
+    protected readonly templateMap: _angular_core.Signal<Record<string, TemplateRef<unknown>>>;
+    protected readonly sortedData: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly paginatedData: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly totalPages: _angular_core.Signal<number>;
+    protected readonly isAllSelected: _angular_core.Signal<boolean>;
+    protected isSelected(row: Record<string, unknown>): boolean;
+    protected toggleSelectAll(checked: boolean): void;
+    protected toggleSelectRow(row: Record<string, unknown>, checked: boolean): void;
+    protected handleSort(col: DynamicTableHeader): void;
+    protected onPageSizeChange(size: number): void;
+    getTemplateForColumn(columnName: string): TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlDynamicTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlDynamicTableComponent, "enl-dynamic-table", never, { "itemsTable": { "alias": "itemsTable"; "required": false; "isSignal": true; }; "headerTable": { "alias": "headerTable"; "required": false; "isSignal": true; }; "selectData": { "alias": "selectData"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "skeletonRows": { "alias": "skeletonRows"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, { "selectedDataChange": "selectedDataChange"; }, ["columnTemplates"], never, true, never>;
+}
+
+declare class EnlConfirmDialogComponent {
+    readonly show: _angular_core.ModelSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly message: _angular_core.InputSignal<string>;
+    readonly confirmLabel: _angular_core.InputSignal<string>;
+    readonly cancelLabel: _angular_core.InputSignal<string>;
+    readonly severity: _angular_core.InputSignal<"success" | "warning" | "info" | "danger">;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly confirmed: _angular_core.OutputEmitterRef<void>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    protected readonly iconName: _angular_core.Signal<IconName>;
+    protected readonly confirmButtonVariant: _angular_core.Signal<ButtonVariant>;
+    handleConfirm(): void;
+    handleCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlConfirmDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlConfirmDialogComponent, "enl-confirm-dialog", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "confirmLabel": { "alias": "confirmLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "show": "showChange"; "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class EnlDynamicCrudComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    readonly items: _angular_core.InputSignal<Record<string, unknown>[]>;
+    readonly tableHeaders: _angular_core.InputSignal<DynamicTableHeader[]>;
+    readonly formSchema: _angular_core.InputSignal<FormFieldConfig[]>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly entityName: _angular_core.InputSignal<string>;
+    readonly fixedModal: _angular_core.InputSignal<boolean>;
+    readonly selectData: _angular_core.InputSignal<boolean>;
+    readonly created: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    readonly updated: _angular_core.OutputEmitterRef<{
+        original: Record<string, unknown>;
+        updated: Record<string, unknown>;
+    }>;
+    readonly deleted: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    readonly selectedDataChange: _angular_core.OutputEmitterRef<Record<string, unknown>[]>;
+    readonly reload: _angular_core.OutputEmitterRef<void>;
+    readonly bulkDeleted: _angular_core.OutputEmitterRef<Record<string, unknown>[]>;
+    readonly showFormModal: _angular_core.WritableSignal<boolean>;
+    readonly showConfirmDelete: _angular_core.WritableSignal<boolean>;
+    readonly selectedItem: _angular_core.WritableSignal<Record<string, unknown> | null>;
+    readonly formValue: _angular_core.WritableSignal<Record<string, unknown>>;
+    readonly isEditMode: _angular_core.WritableSignal<boolean>;
+    readonly formLoading: _angular_core.WritableSignal<boolean>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly selectedItems: _angular_core.WritableSignal<Record<string, unknown>[]>;
+    readonly showConfirmBulkDelete: _angular_core.WritableSignal<boolean>;
+    readonly columnTemplates: _angular_core.Signal<readonly EnlColumnTemplateDirective[]>;
+    protected readonly filteredItems: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly tableHeadersWithActions: _angular_core.Signal<DynamicTableHeader[]>;
+    protected readonly modalTitle: _angular_core.Signal<string>;
+    openCreate(): void;
+    openEdit(row: Record<string, unknown>): void;
+    openDelete(row: Record<string, unknown>): void;
+    handleFormSubmit(value: Record<string, unknown>): void;
+    handleDeleteConfirm(): void;
+    onSelectionChange(selected: Record<string, unknown>[]): void;
+    openBulkDelete(): void;
+    handleBulkDeleteConfirm(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlDynamicCrudComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlDynamicCrudComponent, "enl-dynamic-crud", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "tableHeaders": { "alias": "tableHeaders"; "required": false; "isSignal": true; }; "formSchema": { "alias": "formSchema"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "entityName": { "alias": "entityName"; "required": false; "isSignal": true; }; "fixedModal": { "alias": "fixedModal"; "required": false; "isSignal": true; }; "selectData": { "alias": "selectData"; "required": false; "isSignal": true; }; }, { "created": "created"; "updated": "updated"; "deleted": "deleted"; "selectedDataChange": "selectedDataChange"; "reload": "reload"; "bulkDeleted": "bulkDeleted"; }, ["columnTemplates"], never, true, never>;
+}
+
+declare class EnlAuthTemplateComponent {
+    readonly brandTitle: _angular_core.InputSignal<string>;
+    readonly brandDescription: _angular_core.InputSignal<string>;
+    readonly showThemeToggle: _angular_core.InputSignal<boolean>;
+    readonly themeToggleClick: _angular_core.OutputEmitterRef<void>;
+    protected onThemeToggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlAuthTemplateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlAuthTemplateComponent, "enl-auth-template", never, { "brandTitle": { "alias": "brandTitle"; "required": false; "isSignal": true; }; "brandDescription": { "alias": "brandDescription"; "required": false; "isSignal": true; }; "showThemeToggle": { "alias": "showThemeToggle"; "required": false; "isSignal": true; }; }, { "themeToggleClick": "themeToggleClick"; }, never, ["*"], true, never>;
+}
+
+declare class EnlDashboardTemplateComponent {
+    readonly brandTitle: _angular_core.InputSignal<string>;
+    readonly userEmail: _angular_core.InputSignal<string | undefined>;
+    readonly userAvatarSrc: _angular_core.InputSignal<string | undefined>;
+    readonly userAvatarInitials: _angular_core.InputSignal<string>;
+    readonly sidebarCollapsed: _angular_core.InputSignal<boolean>;
+    readonly sidebarCollapsedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly userProfileClick: _angular_core.OutputEmitterRef<void>;
+    readonly themeToggleClick: _angular_core.OutputEmitterRef<void>;
+    protected onSidebarCollapseChange(collapsed: boolean): void;
+    protected onUserProfileClick(): void;
+    protected onThemeToggleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlDashboardTemplateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlDashboardTemplateComponent, "enl-dashboard-template", never, { "brandTitle": { "alias": "brandTitle"; "required": false; "isSignal": true; }; "userEmail": { "alias": "userEmail"; "required": false; "isSignal": true; }; "userAvatarSrc": { "alias": "userAvatarSrc"; "required": false; "isSignal": true; }; "userAvatarInitials": { "alias": "userAvatarInitials"; "required": false; "isSignal": true; }; "sidebarCollapsed": { "alias": "sidebarCollapsed"; "required": false; "isSignal": true; }; }, { "sidebarCollapsedChange": "sidebarCollapsedChange"; "userProfileClick": "userProfileClick"; "themeToggleClick": "themeToggleClick"; }, never, ["*"], true, never>;
+}
+
+declare class EnlLoginPageComponent {
+    readonly brandTitle: _angular_core.InputSignal<string>;
+    readonly brandDescription: _angular_core.InputSignal<string | undefined>;
+    readonly panelTitle: _angular_core.InputSignal<string>;
+    readonly panelSubtitle: _angular_core.InputSignal<string>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly skeleton: _angular_core.InputSignal<boolean>;
+    readonly errorMessage: _angular_core.InputSignal<string | undefined>;
+    readonly showThemeToggle: _angular_core.InputSignal<boolean>;
+    readonly loginSubmitted: _angular_core.OutputEmitterRef<{
+        email: string;
+        password: string;
+    }>;
+    readonly themeToggleClick: _angular_core.OutputEmitterRef<void>;
+    protected onLoginSubmit(event: {
+        email: string;
+        password: string;
+    }): void;
+    protected onThemeToggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlLoginPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlLoginPageComponent, "enl-login-page", never, { "brandTitle": { "alias": "brandTitle"; "required": false; "isSignal": true; }; "brandDescription": { "alias": "brandDescription"; "required": false; "isSignal": true; }; "panelTitle": { "alias": "panelTitle"; "required": false; "isSignal": true; }; "panelSubtitle": { "alias": "panelSubtitle"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "skeleton": { "alias": "skeleton"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "showThemeToggle": { "alias": "showThemeToggle"; "required": false; "isSignal": true; }; }, { "loginSubmitted": "loginSubmitted"; "themeToggleClick": "themeToggleClick"; }, never, never, true, never>;
+}
+
+declare class EnlDashboardPageComponent {
+    readonly brandTitle: _angular_core.InputSignal<string>;
+    readonly userEmail: _angular_core.InputSignal<string | undefined>;
+    readonly userName: _angular_core.InputSignal<string>;
+    readonly userRole: _angular_core.InputSignal<string>;
+    readonly userAvatarSrc: _angular_core.InputSignal<string | undefined>;
+    readonly userAvatarInitials: _angular_core.InputSignal<string>;
+    readonly sidebarCollapsed: _angular_core.InputSignal<boolean>;
+    readonly tableColumns: _angular_core.InputSignal<TableColumn[]>;
+    readonly tableData: _angular_core.InputSignal<Record<string, unknown>[]>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly sidebarCollapsedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly userProfileClick: _angular_core.OutputEmitterRef<void>;
+    readonly themeToggleClick: _angular_core.OutputEmitterRef<void>;
+    readonly profileActionClick: _angular_core.OutputEmitterRef<string>;
+    readonly logoutClicked: _angular_core.OutputEmitterRef<void>;
+    readonly headers: _angular_core.Signal<DynamicTableHeader[]>;
+    protected onSidebarCollapseChange(collapsed: boolean): void;
+    protected onUserProfileClick(): void;
+    protected onThemeToggleClick(): void;
+    protected onProfileActionClick(action: string): void;
+    protected onLogoutClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnlDashboardPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnlDashboardPageComponent, "enl-dashboard-page", never, { "brandTitle": { "alias": "brandTitle"; "required": false; "isSignal": true; }; "userEmail": { "alias": "userEmail"; "required": false; "isSignal": true; }; "userName": { "alias": "userName"; "required": false; "isSignal": true; }; "userRole": { "alias": "userRole"; "required": false; "isSignal": true; }; "userAvatarSrc": { "alias": "userAvatarSrc"; "required": false; "isSignal": true; }; "userAvatarInitials": { "alias": "userAvatarInitials"; "required": false; "isSignal": true; }; "sidebarCollapsed": { "alias": "sidebarCollapsed"; "required": false; "isSignal": true; }; "tableColumns": { "alias": "tableColumns"; "required": true; "isSignal": true; }; "tableData": { "alias": "tableData"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "sidebarCollapsedChange": "sidebarCollapsedChange"; "userProfileClick": "userProfileClick"; "themeToggleClick": "themeToggleClick"; "profileActionClick": "profileActionClick"; "logoutClicked": "logoutClicked"; }, never, never, true, never>;
+}
+
+export { AnimationTokens, BorderTokens, BreakpointTokens, ColorTokens, EnlAuthTemplateComponent, EnlAvatarComponent, EnlBadgeComponent, EnlButtonComponent, EnlCardComponent, EnlCardHeaderComponent, EnlCheckboxComponent, EnlColumnTemplateDirective, EnlConfirmDialogComponent, EnlDashboardPageComponent, EnlDashboardTemplateComponent, EnlDataTableComponent, EnlDatePickerComponent, EnlDynamicCrudComponent, EnlDynamicFormComponent, EnlDynamicTableComponent, EnlFormFieldComponent, EnlIconComponent, EnlIconFieldComponent, EnlInputComponent, EnlInputNumberComponent, EnlInputOtpComponent, EnlLabelComponent, EnlLoginFormFieldComponent, EnlLoginPageComponent, EnlLoginPanelComponent, EnlModalComponent, EnlMultiSelectComponent, EnlNavbarComponent, EnlPageHeaderComponent, EnlPaginatorComponent, EnlPasswordComponent, EnlRadioComponent, EnlSearchInputComponent, EnlSelectComponent, EnlSidebarComponent, EnlSkeletonCardComponent, EnlSkeletonComponent, EnlSpinnerComponent, EnlStatCardComponent, EnlTextareaComponent, EnlThemeService, EnlToastContainerComponent, EnlToastService, EnlToggleSwitchComponent, EnlTypographyComponent, EnlUserProfileCardComponent, IconPaths, ShadowTokens, SpacingTokens, TypographyTokens, ZIndexTokens };
+export type { AvatarShape, AvatarSize, BadgeShape, BadgeSize, BadgeVariant, ButtonSize, ButtonState, ButtonVariant, CalendarDay, DynamicTableHeader, EnlTheme, FormFieldConfig, IAvatarProps, IBadgeProps, IButtonProps, ICheckboxProps, IIconProps, IInputProps, ILabelProps, IRadioProps, ISpinnerProps, ITypographyProps, IconName, IconSize, InputSize, InputType, SpinnerSize, SpinnerVariant, TableColumn, Toast, ToastType, TypographyAlign, TypographyColor, TypographyElement, TypographyVariant, TypographyWeight };