@neural-ui/core 1.0.0

package/types/neural-ui-core.d.ts

@@ -0,0 +1,2100 @@
+import * as _angular_core from '@angular/core';
+import { EnvironmentProviders, Signal, TemplateRef, InjectionToken, AfterViewInit, OnDestroy, Type } from '@angular/core';
+import { Params } from '@angular/router';
+import { ControlValueAccessor } from '@angular/forms';
+import * as _neural_ui_core from '@neural-ui/core';
+import { SafeHtml } from '@angular/platform-browser';
+import { DialogRef } from '@angular/cdk/dialog';
+
+interface NeuralUIConfig {
+    /** Tamaño por defecto de los iconos. Por defecto: '1.25rem' */
+    iconSize?: string;
+    /** Grosor de trazo de los iconos. Por defecto: '2' */
+    iconStrokeWidth?: string;
+}
+/**
+ * Registra los providers necesarios para NeuralUI.
+ *
+ * Incluye los iconos internos de la librería y la configuración
+ * por defecto de @ng-icons.
+ *
+ * @example
+ * // app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideNeuralUI(),
+ *   ],
+ * };
+ *
+ * @example
+ * // Con opciones personalizadas
+ * provideNeuralUI({ iconSize: '1rem', iconStrokeWidth: '1.5' })
+ */
+declare function provideNeuralUI(config?: NeuralUIConfig): EnvironmentProviders;
+
+/**
+ * NeuUrlStateService — El Sistema Nervioso de NeuralUI
+ *
+ * Sincroniza el estado de la UI con los QueryParams de la URL.
+ * Completamente reactivo via Angular Signals.
+ *
+ * Uso:
+ *   const urlState = inject(NeuUrlStateService);
+ *   const page = urlState.getParam('page');  // Signal<string | null>
+ *   urlState.setParam('menu', 'open');        // Actualiza ?menu=open
+ *   urlState.patchParams({ page: '2', q: 'filter' }); // Actualiza múltiples
+ */
+declare class NeuUrlStateService {
+    private readonly router;
+    /**
+     * Signal con el mapa completo de queryParams actual.
+     * Se actualiza automáticamente en cada NavigationEnd.
+     */
+    readonly params: Signal<Params>;
+    /**
+     * Devuelve un Signal reactivo con el valor del parámetro indicado.
+     * Memorizar el resultado: no llamar en bucle pues crea un computed nuevo c/vez.
+     *
+     * @example
+     *   readonly menuOpen = computed(() => this.urlState.getParam('menu')() === 'open');
+     */
+    getParam(key: string): Signal<string | null>;
+    /**
+     * Establece un único queryParam en la URL.
+     *
+     * @param key       Nombre del parámetro
+     * @param value     Valor. Pasar `null` para eliminarlo de la URL.
+     * @param replaceUrl Si true (default) usa replaceState — no ensucia el historial.
+     *                   Pasar false para acciones que el usuario debe poder deshacer con Atrás.
+     */
+    setParam(key: string, value: string | null, replaceUrl?: boolean): void;
+    /**
+     * Actualiza múltiples queryParams en una sola navegación.
+     *
+     * @example
+     *   urlState.patchParams({ page: '1', q: 'Angular' });
+     */
+    patchParams(params: Record<string, string | null>, replaceUrl?: boolean): void;
+    /**
+     * Elimina todos los queryParams de la URL de una vez.
+     */
+    clearParams(replaceUrl?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuUrlStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NeuUrlStateService>;
+}
+
+type NeuToastType = 'success' | 'error' | 'info' | 'warning';
+type NeuToastPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+interface NeuToastOptions {
+    /** Mensaje del toast */
+    message: string;
+    /** Tipo semántico — controla color e icono */
+    type?: NeuToastType;
+    /** Duración en ms antes de ocultarse automáticamente. 0 = sin auto-hide */
+    duration?: number;
+    /** Título opcional */
+    title?: string;
+}
+interface NeuToastItem extends Required<Omit<NeuToastOptions, 'title'>> {
+    id: string;
+    title: string;
+}
+
+/**
+ * NeuralUI Toast Service
+ *
+ * Lanza notificaciones flotantes desde cualquier punto de la app.
+ * Requiere que `<neu-toast-container>` esté presente en la raíz del app.
+ *
+ * Uso:
+ *   const toast = inject(NeuToastService);
+ *   toast.success('Guardado correctamente');
+ *   toast.error('Ha ocurrido un error', { title: 'Error', duration: 8000 });
+ */
+declare class NeuToastService {
+    /** Lista reactiva de toasts activos */
+    readonly toasts: _angular_core.WritableSignal<NeuToastItem[]>;
+    /** Posición del contenedor de toasts */
+    readonly position: _angular_core.WritableSignal<NeuToastPosition>;
+    setPosition(position: NeuToastPosition): void;
+    show(options: NeuToastOptions): string;
+    success(message: string, opts?: Partial<NeuToastOptions>): string;
+    error(message: string, opts?: Partial<NeuToastOptions>): string;
+    info(message: string, opts?: Partial<NeuToastOptions>): string;
+    warning(message: string, opts?: Partial<NeuToastOptions>): string;
+    dismiss(id: string): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NeuToastService>;
+}
+
+/**
+ * NeuralUI Checkbox Component
+ *
+ * Checkbox personalizado y accesible para Angular Forms.
+ *
+ * Uso:
+ *   <neu-checkbox label="Acepto los términos" [formControl]="termsCtrl" />
+ */
+declare class NeuCheckboxComponent implements ControlValueAccessor {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly _id: string;
+    protected readonly _checked: _angular_core.WritableSignal<boolean>;
+    /** Estado disabled interno — combina el input `disabled` con el CVA setDisabledState */
+    private readonly _cvaDisabled;
+    protected readonly _isDisabled: _angular_core.Signal<boolean>;
+    private _onChange;
+    private _onTouched;
+    onChange(event: Event): void;
+    onBlur(): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuCheckboxComponent, "neu-checkbox", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface CalendarDay {
+    date: Date;
+    inMonth: boolean;
+    isToday: boolean;
+    isSelected: boolean;
+}
+interface DrumSlot {
+    value: number;
+    offset: number;
+    label: string;
+}
+declare class NeuDateInputComponent implements ControlValueAccessor {
+    private readonly el;
+    /** Tipo: date | time | datetime-local */
+    type: _angular_core.InputSignal<"date" | "time" | "datetime-local">;
+    /** Etiqueta del campo */
+    label: _angular_core.InputSignal<string>;
+    /** Texto de ayuda */
+    hint: _angular_core.InputSignal<string>;
+    /** Mensaje de error */
+    errorMessage: _angular_core.InputSignal<string>;
+    /** Deshabilita el campo */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Solo lectura */
+    readonly: _angular_core.InputSignal<boolean>;
+    /** Nombre del campo (formularios nativos) */
+    name: _angular_core.InputSignal<string>;
+    /** ID accesible */
+    inputId: _angular_core.InputSignal<string>;
+    /** Requerido */
+    required: _angular_core.InputSignal<boolean>;
+    /** Mínimo (no implementado visualmente en v1) */
+    min: _angular_core.InputSignal<string | null>;
+    /** Máximo (no implementado visualmente en v1) */
+    max: _angular_core.InputSignal<string | null>;
+    /** Paso */
+    step: _angular_core.InputSignal<number | null>;
+    protected readonly _id: string;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly _value: _angular_core.WritableSignal<string>;
+    protected readonly _viewYear: _angular_core.WritableSignal<number>;
+    protected readonly _viewMonth: _angular_core.WritableSignal<number>;
+    protected readonly _selYear: _angular_core.WritableSignal<number | null>;
+    protected readonly _selMonth: _angular_core.WritableSignal<number | null>;
+    protected readonly _selDay: _angular_core.WritableSignal<number | null>;
+    protected readonly _selHour: _angular_core.WritableSignal<number>;
+    protected readonly _selMinute: _angular_core.WritableSignal<number>;
+    readonly hasError: _angular_core.Signal<boolean>;
+    readonly displayValue: _angular_core.Signal<string>;
+    readonly placeholderText: _angular_core.Signal<"hh:mm" | "dd/mm/aaaa, hh:mm" | "dd/mm/aaaa">;
+    readonly monthLabel: _angular_core.Signal<string>;
+    readonly weekdays: string[];
+    readonly calendarDays: _angular_core.Signal<CalendarDay[]>;
+    readonly hourSlots: _angular_core.Signal<DrumSlot[]>;
+    readonly minuteSlots: _angular_core.Signal<DrumSlot[]>;
+    private _drumSlots;
+    toggle(): void;
+    close(): void;
+    onDocumentClick(event: MouseEvent): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    selectDay(day: CalendarDay): void;
+    formatDayLabel(date: Date): string;
+    today(): void;
+    clear(): void;
+    changeHour(delta: number): void;
+    changeMinute(delta: number): void;
+    onHourWheel(e: WheelEvent): void;
+    onMinuteWheel(e: WheelEvent): void;
+    private _emitValue;
+    private _onChange;
+    private _onTouched;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    private readonly _cvaDisabled;
+    setDisabledState(isDisabled: boolean): void;
+    readonly isDisabledFinal: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuDateInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuDateInputComponent, "neu-date-input", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuInputType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search';
+/**
+ * NeuralUI Input Component
+ *
+ * Input con floating label, iconos y soporte completo para Angular Forms.
+ * Compatible con ReactiveFormsModule y ngModel.
+ *
+ * Uso standalone:
+ *   <neu-input label="Correo" type="email" />
+ *
+ * Con Reactive Forms:
+ *   <neu-input label="Correo" [formControl]="emailCtrl" [errorMessage]="emailError()" />
+ */
+declare class NeuInputComponent implements ControlValueAccessor {
+    /** Tipo de input HTML */
+    type: _angular_core.InputSignal<NeuInputType>;
+    /** Texto del floating label */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder visible cuando floatingLabel=false */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Muestra el label como flotante (true) o estático encima del campo (false) */
+    floatingLabel: _angular_core.InputSignal<boolean>;
+    /** Hint de ayuda (visible cuando no hay error) */
+    hint: _angular_core.InputSignal<string>;
+    /** Mensaje de error (activa el estado de error) */
+    errorMessage: _angular_core.InputSignal<string>;
+    /** Deshabilita el campo */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Atributo autocomplete HTML */
+    autocomplete: _angular_core.InputSignal<string>;
+    /** Muestra zona para icono al inicio */
+    startIcon: _angular_core.InputSignal<boolean>;
+    /** Muestra zona para icono al final */
+    endIcon: _angular_core.InputSignal<boolean>;
+    /** Nombre del icono lucide a renderizar dentro del campo */
+    icon: _angular_core.InputSignal<string>;
+    /** Posición del icono cuando se usa `icon` */
+    iconPosition: _angular_core.InputSignal<"left" | "right">;
+    /** ID accesible para el input — generado con contador estable (seguro en SSR) */
+    inputId: _angular_core.InputSignal<string>;
+    /** Nombre del campo para formularios nativos */
+    name: _angular_core.InputSignal<string>;
+    /** Marca el campo como requerido */
+    required: _angular_core.InputSignal<boolean>;
+    /** Hace el campo de solo lectura */
+    readonly: _angular_core.InputSignal<boolean>;
+    /** Longitud máxima de caracteres */
+    maxlength: _angular_core.InputSignal<number | null>;
+    /** Longitud mínima de caracteres */
+    minlength: _angular_core.InputSignal<number | null>;
+    /** Valor mínimo (para type=number/date) */
+    min: _angular_core.InputSignal<string | null>;
+    /** Valor máximo (para type=number/date) */
+    max: _angular_core.InputSignal<string | null>;
+    /** Patrón de validación HTML5 */
+    pattern: _angular_core.InputSignal<string | null>;
+    protected readonly _value: _angular_core.WritableSignal<string>;
+    protected readonly _focused: _angular_core.WritableSignal<boolean>;
+    readonly hasValue: _angular_core.Signal<boolean>;
+    readonly hasError: _angular_core.Signal<boolean>;
+    readonly startIconPath: _angular_core.Signal<string>;
+    readonly hasStartContent: _angular_core.Signal<boolean>;
+    readonly _hasIconLeft: _angular_core.Signal<boolean>;
+    readonly _hasIconRight: _angular_core.Signal<boolean>;
+    private _onChange;
+    private _onTouched;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    private readonly _cvaDisabled;
+    setDisabledState(isDisabled: boolean): void;
+    readonly isDisabledFinal: _angular_core.Signal<boolean>;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuInputComponent, "neu-input", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "startIcon": { "alias": "startIcon"; "required": false; "isSignal": true; }; "endIcon": { "alias": "endIcon"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "minlength": { "alias": "minlength"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, {}, never, ["[neu-input-start]", "[neu-input-end]"], true, never>;
+}
+
+interface NeuSelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+}
+interface NeuSelectGroup {
+    label: string;
+    options: NeuSelectOption[];
+}
+
+/**
+ * Directiva para personalizar el template de cada ítem del dropdown de Multiselect.
+ *
+ * Uso:
+ * ```html
+ * <neu-multiselect [options]="opts" [(ngModel)]="values">
+ *   <ng-template neuMultiselectItem let-item>
+ *     <span class="flag flag-{{ item.value }}"></span>
+ *     {{ item.label }}
+ *   </ng-template>
+ * </neu-multiselect>
+ * ```
+ */
+declare class NeuMultiselectItemDirective {
+    readonly templateRef: TemplateRef<{
+        $implicit: NeuSelectOption;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuMultiselectItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuMultiselectItemDirective, "[neuMultiselectItem]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Multiselect Component
+ *
+ * Dropdown de selección múltiple con chips, búsqueda integrada y soporte
+ * completo para Angular Forms (ngModel y Reactive Forms).
+ *
+ * Uso:
+ *   <neu-multiselect label="Tecnologías" [options]="opts" [(ngModel)]="selected" />
+ */
+declare class NeuMultiselectComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    /** @internal */
+    readonly _triggerId: string;
+    /** Template personalizado para cada opción del dropdown */
+    readonly itemTpl: _angular_core.Signal<NeuMultiselectItemDirective | undefined>;
+    /** Opciones del dropdown */
+    options: _angular_core.InputSignal<NeuSelectOption[]>;
+    /** Etiqueta del componente */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder cuando no hay selección */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Mensaje de error */
+    errorMessage: _angular_core.InputSignal<string>;
+    /** Deshabilita el componente */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Activa input de búsqueda/filtro en el panel */
+    searchable: _angular_core.InputSignal<boolean>;
+    /** Placeholder del input de búsqueda */
+    searchPlaceholder: _angular_core.InputSignal<string>;
+    /** Texto cuando no hay opciones tras filtrar */
+    noResultsMessage: _angular_core.InputSignal<string>;
+    /** Texto del botón de limpiar todas las selecciones */
+    clearAllLabel: _angular_core.InputSignal<string>;
+    /** Muestra un botón × en el trigger para limpiar la selección de una vez */
+    clearable: _angular_core.InputSignal<boolean>;
+    /** Aria-label del botón clear que aparece en el trigger */
+    clearAriaLabel: _angular_core.InputSignal<string>;
+    protected readonly _values: _angular_core.WritableSignal<string[]>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly _chipMode: _angular_core.WritableSignal<"chips" | "count">;
+    readonly _visibleChips: _angular_core.Signal<string[]>;
+    readonly hasError: _angular_core.Signal<boolean>;
+    readonly filteredOptions: _angular_core.Signal<NeuSelectOption[]>;
+    private _onChange;
+    private _onTouched;
+    writeValue(value: string[] | null): void;
+    registerOnChange(fn: (v: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    private readonly _cvaDisabled;
+    setDisabledState(isDisabled: boolean): void;
+    readonly isDisabledFinal: _angular_core.Signal<boolean>;
+    protected labelFor(value: string): string;
+    protected isSelected(value: string): boolean;
+    protected toggle(): void;
+    /** Abre el panel y mueve el foco al primer item */
+    onTriggerKey(event: Event): void;
+    /** Navega entre opciones con flechas */
+    focusOptionByIndex(event: Event, current: NeuSelectOption, dir: 1 | -1): void;
+    protected close(): void;
+    protected toggleOption(option: NeuSelectOption): void;
+    protected removeValue(value: string, event: MouseEvent): void;
+    protected clearAll(event: MouseEvent): void;
+    protected toggleChipMode(event: MouseEvent): void;
+    protected onDocumentClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuMultiselectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuMultiselectComponent, "neu-multiselect", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "noResultsMessage": { "alias": "noResultsMessage"; "required": false; "isSignal": true; }; "clearAllLabel": { "alias": "clearAllLabel"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; }, {}, ["itemTpl"], never, true, never>;
+}
+
+/** Token para que neu-radio encuentre a su grupo padre */
+declare const NEU_RADIO_GROUP: InjectionToken<NeuRadioGroupComponent>;
+declare class NeuRadioGroupComponent implements ControlValueAccessor {
+    readonly direction: _angular_core.InputSignal<"row" | "column">;
+    /** Etiqueta accesible del grupo (WCAG 4.1.2). Usar cuando no hay <legend> visible. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Nombre HTML compartido por todos los neu-radio hijos — garantiza la exclusión mutua nativa */
+    readonly _name: string;
+    readonly _value: _angular_core.WritableSignal<unknown>;
+    readonly _isDisabled: _angular_core.WritableSignal<boolean>;
+    private _onChange;
+    private _onTouched;
+    select(value: unknown): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuRadioGroupComponent, "neu-radio-group", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * NeuralUI Radio Component
+ *
+ * Opción individual dentro de un neu-radio-group.
+ *
+ * Uso:
+ *   <neu-radio value="opcion-a" label="Opción A" />
+ */
+declare class NeuRadioComponent {
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly group: _neural_ui_core.NeuRadioGroupComponent;
+    readonly _id: string;
+    /** Toma el nombre del grupo padre — así todos los radios del grupo comparten el mismo `name` nativo */
+    readonly _groupName: string;
+    readonly isChecked: _angular_core.Signal<boolean>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    onSelect(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuRadioComponent, "neu-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directiva para personalizar el template de cada ítem del dropdown.
+ *
+ * Uso:
+ * ```html
+ * <neu-select [options]="opts" [(ngModel)]="value">
+ *   <ng-template neuSelectItem let-item>
+ *     <span class="flag flag-{{ item.value }}"></span>
+ *     {{ item.label }}
+ *   </ng-template>
+ * </neu-select>
+ * ```
+ */
+declare class NeuSelectItemDirective {
+    readonly templateRef: TemplateRef<{
+        $implicit: NeuSelectOption;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSelectItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuSelectItemDirective, "[neuSelectItem]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directiva para personalizar el template del ítem seleccionado (trigger).
+ *
+ * Uso:
+ * ```html
+ * <neu-select [options]="opts" [(ngModel)]="value">
+ *   <ng-template neuSelectSelected let-item>
+ *     <strong>{{ item?.label }}</strong>
+ *   </ng-template>
+ * </neu-select>
+ * ```
+ */
+declare class NeuSelectSelectedDirective {
+    readonly templateRef: TemplateRef<{
+        $implicit: NeuSelectOption | null;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSelectSelectedDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuSelectSelectedDirective, "[neuSelectSelected]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Select Component
+ *
+ * Dropdown personalizado con soporte para Angular Forms.
+ * Cierra automáticamente al hacer clic fuera del componente.
+ *
+ * Uso:
+ *   <neu-select label="País" [options]="paises" [(ngModel)]="country" />
+ *
+ * Con Reactive Forms:
+ *   <neu-select label="País" [options]="paises" [formControl]="countryCtrl" />
+ */
+declare class NeuSelectComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    /** @internal — ID \u00fanico para asociar label con trigger */
+    readonly _triggerId: string;
+    /** Template personalizado para cada opción del dropdown */
+    readonly itemTpl: _angular_core.Signal<NeuSelectItemDirective | undefined>;
+    /** Template personalizado para el valor seleccionado en el trigger */
+    readonly selectedItemTpl: _angular_core.Signal<NeuSelectSelectedDirective | undefined>;
+    /** Opciones del dropdown */
+    options: _angular_core.InputSignal<NeuSelectOption[]>;
+    /** Texto del floating label */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder cuando no hay selección */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Mensaje de error */
+    errorMessage: _angular_core.InputSignal<string>;
+    /** Deshabilita el select */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Muestra el label como flotante (true) o como label estático encima (false, por defecto) */
+    floatingLabel: _angular_core.InputSignal<boolean>;
+    /** Activa input de búsqueda/filtro en el panel */
+    searchable: _angular_core.InputSignal<boolean>;
+    /** Placeholder del input de búsqueda */
+    searchPlaceholder: _angular_core.InputSignal<string>;
+    /** Muestra un botón para limpiar la selección */
+    clearable: _angular_core.InputSignal<boolean>;
+    /** Texto cuando no hay opciones tras filtrar */
+    noResultsMessage: _angular_core.InputSignal<string>;
+    /** Aria-label del botón de limpiar */
+    clearAriaLabel: _angular_core.InputSignal<string>;
+    protected readonly _value: _angular_core.WritableSignal<string | null>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly hasError: _angular_core.Signal<boolean>;
+    readonly filteredOptions: _angular_core.Signal<NeuSelectOption[]>;
+    readonly selectedLabel: _angular_core.Signal<string | null>;
+    readonly _selectedOption: _angular_core.Signal<NeuSelectOption | null>;
+    private _onChange;
+    private _onTouched;
+    writeValue(val: string | null): void;
+    registerOnChange(fn: (v: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    private readonly _cvaDisabled;
+    setDisabledState(isDisabled: boolean): void;
+    readonly isDisabledFinal: _angular_core.Signal<boolean>;
+    toggle(): void;
+    close(): void;
+    /** Abre el panel y navega con flechas desde el trigger */
+    onTriggerKey(event: Event): void;
+    /** Navega entre opciones con flechas */
+    focusOptionByIndex(event: Event, current: NeuSelectOption, dir: 1 | -1): void;
+    clearValue(event: MouseEvent): void;
+    selectOption(option: NeuSelectOption): void;
+    onDocumentClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuSelectComponent, "neu-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "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; }; "noResultsMessage": { "alias": "noResultsMessage"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; }, {}, ["itemTpl", "selectedItemTpl"], never, true, never>;
+}
+
+/**
+ * NeuralUI Slider Component
+ *
+ * Control deslizante accesible que envuelve el <input type="range">
+ * nativo con estilos personalizados y tooltips de valor.
+ *
+ * Uso:
+ *   <neu-slider [value]="volume" (valueChange)="volume = $event" />
+ *   <neu-slider [value]="50" [min]="0" [max]="100" [step]="5" [showValue]="true" />
+ */
+declare class NeuSliderComponent {
+    private static _idCounter;
+    protected readonly sliderId: string;
+    /** Valor actual */
+    value: _angular_core.InputSignal<number>;
+    /** Valor mínimo */
+    min: _angular_core.InputSignal<number>;
+    /** Valor máximo */
+    max: _angular_core.InputSignal<number>;
+    /** Paso */
+    step: _angular_core.InputSignal<number>;
+    /** Etiqueta */
+    label: _angular_core.InputSignal<string>;
+    /** Muestra el valor numerico */
+    showValue: _angular_core.InputSignal<boolean>;
+    /** Muestra min/mid/max bajo la barra */
+    showTicks: _angular_core.InputSignal<boolean>;
+    /** Unidad a mostrar junto al valor */
+    unit: _angular_core.InputSignal<string>;
+    /** Deshabilitado */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Emite al mover el slider */
+    valueChange: _angular_core.OutputEmitterRef<number>;
+    readonly fillPercent: _angular_core.Signal<number>;
+    onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuSliderComponent, "neu-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "showTicks": { "alias": "showTicks"; "required": false; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Switch Component
+ *
+ * Toggle animado para formularios de configuración en dashboards.
+ * Usa el Electric-Blue (--neu-primary) cuando está activo.
+ *
+ * Uso:
+ *   <neu-switch label="Notificaciones" [formControl]="notifsCtrl" />
+ */
+declare class NeuSwitchComponent implements ControlValueAccessor {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly _id: string;
+    protected readonly _checked: _angular_core.WritableSignal<boolean>;
+    /** Estado disabled interno — combina el input `disabled` con el CVA setDisabledState */
+    private readonly _cvaDisabled;
+    protected readonly _isDisabled: _angular_core.Signal<boolean>;
+    private _onChange;
+    private _onTouched;
+    onChange(event: Event): void;
+    onBlur(): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuSwitchComponent, "neu-switch", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Textarea Component
+ *
+ * Textarea con floating label y soporte completo para Angular Forms.
+ * Soporta auto-resize opcional.
+ *
+ * Uso:
+ *   <neu-textarea label="Descripción" [formControl]="ctrl" />
+ *   <neu-textarea label="Bio" [rows]="5" [autoResize]="true" />
+ */
+declare class NeuTextareaComponent implements ControlValueAccessor {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly autoResize: _angular_core.InputSignal<boolean>;
+    /** Permite al usuario redimensionar el campo manualmente (por defecto: true) */
+    readonly resizable: _angular_core.InputSignal<boolean>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    readonly hint: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly maxlength: _angular_core.InputSignal<number | null>;
+    readonly _id: string;
+    protected readonly _value: _angular_core.WritableSignal<string>;
+    protected readonly _focused: _angular_core.WritableSignal<boolean>;
+    protected readonly _isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly _isDisabledState: _angular_core.Signal<boolean>;
+    readonly hasValue: _angular_core.Signal<boolean>;
+    readonly hasError: _angular_core.Signal<boolean>;
+    readonly _resizeStyle: _angular_core.Signal<"none" | "vertical">;
+    private readonly _textareaRef;
+    private _onChange;
+    private _onTouched;
+    constructor();
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuTextareaComponent, "neu-textarea", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "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; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger' | 'outline';
+type NeuButtonSize = 'sm' | 'md' | 'lg';
+type NeuButtonIconPosition = 'left' | 'right';
+/**
+ * NeuralUI Button Component
+ *
+ * Uso: <button neu-button variant="primary" size="md">Texto</button>
+ * Con icono: <button neu-button icon="lucideSave">Guardar</button>
+ * Solo icono: <button neu-button icon="lucideTrash2" [iconOnly]="true" />
+ *
+ * Signals: variant, size, disabled, loading, fullWidth, icon, iconPosition, iconOnly
+ * son inputs reactivos. El estado se computa automáticamente con computed().
+ */
+declare class NeuButtonComponent {
+    /** Variante visual del botón */
+    variant: _angular_core.InputSignal<NeuButtonVariant>;
+    /** Tamaño del botón */
+    size: _angular_core.InputSignal<NeuButtonSize>;
+    /** Deshabilita el botón y bloquea la interacción */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Muestra un spinner y deshabilita mientras se procesa */
+    loading: _angular_core.InputSignal<boolean>;
+    /** Ocupa el 100% del ancho de su contenedor */
+    fullWidth: _angular_core.InputSignal<boolean>;
+    /** Nombre del icono Lucide (ej: 'lucideSave', 'lucidePlus') */
+    icon: _angular_core.InputSignal<string>;
+    /** Posición del icono respecto al texto */
+    iconPosition: _angular_core.InputSignal<NeuButtonIconPosition>;
+    /** Modo solo-icono: aplica padding cuadrado y oculta el ng-content */
+    iconOnly: _angular_core.InputSignal<boolean>;
+    /** Etiqueta accesible obligatoria cuando se usa iconOnly (WCAG 4.1.2) */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /** Emite el evento de click cuando el botón está activo */
+    neuClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** @internal — reenvía el click nativo al output Angular */
+    _onHostClick(event: MouseEvent): void;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    readonly hasIcon: _angular_core.Signal<boolean>;
+    readonly iconSize: _angular_core.Signal<string>;
+    readonly hostClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        'neu-button': boolean;
+        'neu-button--loading': boolean;
+        'neu-button--disabled': boolean;
+        'neu-button--full-width': boolean;
+        'neu-button--icon-only': boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuButtonComponent, "button[neu-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; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "neuClick": "neuClick"; }, never, ["*"], true, never>;
+}
+
+interface NeuToggleOption<T = unknown> {
+    /** Texto visible del botón */
+    label: string;
+    /** Valor asociado a esta opción */
+    value: T;
+    /** Nombre de icono Lucide (opcional) */
+    icon?: string;
+    /** Deshabilita solo esta opción */
+    disabled?: boolean;
+}
+/**
+ * NeuralUI ToggleButtonGroup Component
+ *
+ * Grupo de botones de selección (single o múltiple).
+ * Equivalente técnicamente superior al SelectButton de PrimeNG.
+ *
+ * Uso (single):
+ *   <neu-toggle-button-group [options]="opts" [(ngModel)]="value" />
+ *
+ * Uso (múltiple):
+ *   <neu-toggle-button-group [options]="opts" [multiple]="true" [(ngModel)]="values" />
+ */
+declare class NeuToggleButtonGroupComponent<T = unknown> implements ControlValueAccessor {
+    /** Lista de opciones del grupo */
+    options: _angular_core.InputSignal<NeuToggleOption<T>[]>;
+    /**
+     * Permite seleccionar múltiples opciones.
+     * - false (por defecto): valor es `T | null`
+     * - true: valor es `T[]`
+     */
+    multiple: _angular_core.InputSignal<boolean>;
+    /** Tamaño visual */
+    size: _angular_core.InputSignal<NeuButtonSize>;
+    /** Deshabilita todo el grupo */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Emite el nuevo valor al cambiar (útil sin formControl) */
+    neuChange: _angular_core.OutputEmitterRef<T | T[] | null>;
+    readonly _value: _angular_core.WritableSignal<T | T[] | null>;
+    readonly _isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly groupClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        'neu-toggle-group': boolean;
+        'neu-toggle-group--disabled': boolean;
+    }>;
+    isSelected(value: T): boolean;
+    toggle(opt: NeuToggleOption<T>): void;
+    onBlur(): void;
+    private _onChange;
+    private _onTouched;
+    writeValue(val: T | T[] | null): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuToggleButtonGroupComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuToggleButtonGroupComponent<any>, "neu-toggle-button-group", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "neuChange": "neuChange"; }, never, never, true, never>;
+}
+
+interface NeuBreadcrumbItem {
+    /** Etiqueta visible */
+    label: string;
+    /** Ruta interna (RouterLink) */
+    route?: string | string[];
+    /** URL externa */
+    url?: string;
+    /** Icono Lucide opcional */
+    icon?: string;
+}
+/**
+ * NeuralUI Breadcrumb Component
+ *
+ * Ruta de navegación jerárquica. El último elemento se muestra
+ * como activo (sin enlace).
+ *
+ * Uso:
+ *   <neu-breadcrumb [items]="breadcrumbs" />
+ *
+ *   items = [
+ *     { label: 'Inicio', route: '/' },
+ *     { label: 'Componentes', route: '/components' },
+ *     { label: 'Breadcrumb' },
+ *   ];
+ */
+declare class NeuBreadcrumbComponent {
+    /** Lista de ítems de navegación */
+    items: _angular_core.InputSignal<NeuBreadcrumbItem[]>;
+    /** Separador personalizable */
+    separator: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuBreadcrumbComponent, "neu-breadcrumb", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Ítem de navegación con soporte para 3 niveles de profundidad.
+ *
+ * Destino del enlace — usa UNO de los dos:
+ *   - `route`  → navegación interna Angular (RouterLink)
+ *   - `href`   → URL externa, se abre en nueva pestaña con rel="noopener noreferrer"
+ *
+ * Los ítems con `children` actúan como grupo acordeón (sin destino propio).
+ * Máximo 3 niveles: raíz → hijos → nietos.
+ * Los nietos no pueden tener `children`.
+ */
+interface NeuNavItem {
+    id: string;
+    label: string;
+    icon: string;
+    /** Ruta Angular interna (RouterLink). Excluye `href`. */
+    route?: string;
+    /** URL externa. Se abre en nueva pestaña. Excluye `route`. */
+    href?: string;
+    /** Ítems hijo (nivel 2). Cada hijo puede tener sus propios `children` (nivel 3). */
+    children?: NeuNavItem[];
+    badge?: string;
+    badgeVariant?: 'default' | 'success' | 'warning' | 'danger' | 'info';
+    disabled?: boolean;
+}
+declare class NeuNavComponent {
+    private readonly router;
+    private readonly currentUrl;
+    /** Lista de ítems de navegación */
+    items: _angular_core.InputSignal<NeuNavItem[]>;
+    /** Estado inicial colapsado */
+    collapsed: _angular_core.InputSignal<boolean>;
+    /** Muestra el botón de colapsar/expandir */
+    collapsible: _angular_core.InputSignal<boolean>;
+    /** Etiqueta accesible del <nav> */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón cuando el nav está colapsado */
+    expandLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón cuando el nav está expandido */
+    collapseLabel: _angular_core.InputSignal<string>;
+    /** Emite cuando cambia el estado colapsado */
+    collapsedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly isCollapsed: _angular_core.WritableSignal<boolean>;
+    private readonly openGroups;
+    readonly flyoutState: _angular_core.WritableSignal<{
+        item: NeuNavItem;
+        top: number;
+        left: number;
+    } | null>;
+    private _flyoutTimer;
+    constructor();
+    toggleCollapse(): void;
+    toggleGroup(id: string): void;
+    isGroupOpen(id: string): boolean;
+    isCurrentRoute(route: string): boolean;
+    isGroupActive(item: NeuNavItem): boolean;
+    onGroupMouseEnter(item: NeuNavItem, event: MouseEvent): void;
+    onGroupMouseLeave(): void;
+    onFlyoutMouseEnter(): void;
+    onFlyoutMouseLeave(): void;
+    private _openActiveGroup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuNavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuNavComponent, "neu-nav", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "expandLabel": { "alias": "expandLabel"; "required": false; "isSignal": true; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; "isSignal": true; }; }, { "collapsedChange": "collapsedChange"; }, never, ["[neu-nav-brand-icon]", "[neu-nav-brand]", "[neu-nav-footer]"], true, never>;
+}
+
+/**
+ * NeuralUI Pagination Component
+ *
+ * Paginación accesible con navegación por páginas, primera/última y ellipsis.
+ *
+ * Uso:
+ *   <neu-pagination [total]="200" [pageSize]="10" [page]="currentPage"
+ *                  (pageChange)="currentPage = $event" />
+ */
+declare class NeuPaginationComponent {
+    /** Página actual (1-indexed) */
+    page: _angular_core.InputSignal<number>;
+    /** Total de ítems */
+    total: _angular_core.InputSignal<number>;
+    /** Ítems por página */
+    pageSize: _angular_core.InputSignal<number>;
+    /** Número máximo de botones de página visibles (sin contar anterior/siguiente) */
+    maxVisible: _angular_core.InputSignal<number>;
+    /** Emite la nueva página al hacer click */
+    pageChange: _angular_core.OutputEmitterRef<number>;
+    readonly totalPages: _angular_core.Signal<number>;
+    readonly pages: _angular_core.Signal<number[]>;
+    go(page: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuPaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuPaginationComponent, "neu-pagination", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "maxVisible": { "alias": "maxVisible"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Sidebar Component
+ *
+ * El estado abierto/cerrado se gestiona automáticamente desde la URL
+ * via NeuUrlStateService (?menu=open por defecto).
+ *
+ * Modos:
+ *   - overlay (default): panel flotante sobre el contenido con backdrop
+ *   - persistent: sidebar fijo integrado en el layout (desktop)
+ *
+ * Uso:
+ *   <neu-sidebar urlParam="menu" [persistent]="isDesktop()">
+ *     <span neu-sidebar-header>Mi App</span>
+ *     <nav>...</nav>
+ *     <div neu-sidebar-footer>...</div>
+ *   </neu-sidebar>
+ *
+ * Abrir desde cualquier parte:
+ *   inject(NeuUrlStateService).setParam('menu', 'open', false);
+ */
+declare class NeuSidebarComponent {
+    private readonly urlState;
+    /** Posición del sidebar: izquierda o derecha de la pantalla */
+    side: _angular_core.InputSignal<"left" | "right">;
+    /** QueryParam que controla el estado. Default: 'menu' (?menu=open) */
+    urlParam: _angular_core.InputSignal<string>;
+    /**
+     * Modo persistente: el sidebar está siempre visible como parte del layout.
+     * Usar en desktop (≥768px). El overlay y el toggle por URL no aplican.
+     */
+    persistent: _angular_core.InputSignal<boolean>;
+    /**
+     * Ocultar la cabecera del sidebar. Útil cuando el header ya está en el layout
+     * principal y el sidebar persistente no necesita su propio header.
+     */
+    hideHeader: _angular_core.InputSignal<boolean>;
+    /** Etiqueta accesible para el <aside> */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /** Etiqueta accesible para el botón cerrar */
+    closeLabel: _angular_core.InputSignal<string>;
+    /** Emite cuando el usuario cierra el sidebar (overlay click o botón) */
+    closeRequested: _angular_core.OutputEmitterRef<void>;
+    /** Signal reactivo: true si el sidebar debe mostrarse */
+    readonly isOpen: _angular_core.Signal<boolean>;
+    /** Abre el sidebar — añade ?{urlParam}=open a la URL */
+    open(replaceUrl?: boolean): void;
+    /** Cierra el sidebar — elimina el parámetro de la URL */
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuSidebarComponent, "neu-sidebar", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "urlParam": { "alias": "urlParam"; "required": false; "isSignal": true; }; "persistent": { "alias": "persistent"; "required": false; "isSignal": true; }; "hideHeader": { "alias": "hideHeader"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "closeRequested": "closeRequested"; }, never, ["[neu-sidebar-header]", "*", "[neu-sidebar-footer]"], true, never>;
+}
+
+interface NeuStepperStep {
+    /** Etiqueta del paso */
+    label: string;
+    /** Descripción corta opcional */
+    description?: string;
+    /** Marca el paso como completado externamente */
+    completed?: boolean;
+    /** Desactiva el paso */
+    disabled?: boolean;
+}
+/**
+ * NeuralUI Stepper Component
+ *
+ * Wizard paso a paso con estado de completado, lineal u opcional.
+ * Expone métodos next() / prev() y emite stepChange.
+ *
+ * Uso:
+ *   <neu-stepper [steps]="steps" [activeStep]="step" (stepChange)="step = $event">
+ *     <ng-template neuStepContent>Contenido paso 1</ng-template>
+ *     <ng-template neuStepContent>Contenido paso 2</ng-template>
+ *   </neu-stepper>
+ */
+declare class NeuStepperComponent {
+    /** Pasos del wizard */
+    steps: _angular_core.InputSignal<NeuStepperStep[]>;
+    /** Índice del paso activo (0-based) */
+    activeStep: _angular_core.InputSignal<number>;
+    /** Si true, solo permite ir hacia adelante secuencialmente */
+    linear: _angular_core.InputSignal<boolean>;
+    /** Emite el nuevo índice al cambiar */
+    stepChange: _angular_core.OutputEmitterRef<number>;
+    /** Set de pasos completados */
+    private readonly _completed;
+    readonly isCompleted: (i: number) => boolean;
+    goTo(i: number): void;
+    /** Marca el paso actual como completado y avanza al siguiente */
+    next(): void;
+    prev(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuStepperComponent, "neu-stepper", never, { "steps": { "alias": "steps"; "required": false; "isSignal": true; }; "activeStep": { "alias": "activeStep"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; }, { "stepChange": "stepChange"; }, never, ["*"], true, never>;
+}
+
+declare const NEU_TABS_CONTEXT: InjectionToken<NeuTabsComponent>;
+interface NeuTab {
+    /** ID único de la pestaña — se usa como valor en la URL */
+    id: string;
+    /** Etiqueta visible */
+    label: string;
+    /** Badge opcional junto al label */
+    badge?: string;
+    /** Deshabilita la pestaña sin ocultarla */
+    disabled?: boolean;
+}
+/**
+ * NeuralUI Tabs Component
+ *
+ * Sistema de pestañas con estado sincronizado a la URL via NeuUrlStateService.
+ * El panel activo se determina por ?{tabParam}={tabId}.
+ *
+ * Uso:
+ *   <neu-tabs [tabs]="tabs" tabParam="tab">
+ *     <neu-tab-panel tabId="preview">...</neu-tab-panel>
+ *     <neu-tab-panel tabId="api">...</neu-tab-panel>
+ *   </neu-tabs>
+ */
+declare class NeuTabsComponent implements AfterViewInit, OnDestroy {
+    private readonly urlState;
+    private readonly elRef;
+    private resizeObserver?;
+    constructor();
+    /** Definición de pestañas */
+    tabs: _angular_core.InputSignal<NeuTab[]>;
+    /** QueryParam que almacena la pestaña activa */
+    tabParam: _angular_core.InputSignal<string>;
+    /** Si true, elimina el padding interno de los paneles */
+    flush: _angular_core.InputSignal<boolean>;
+    /** Etiqueta accesible del rol tablist */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /** Emite al cambiar de pestaña */
+    tabChange: _angular_core.OutputEmitterRef<string>;
+    /** ID de la pestaña activa (de la URL o la primera disponible) */
+    readonly activeTabId: _angular_core.Signal<string>;
+    /** Posición del indicador calculada mediante medición DOM */
+    private readonly _indicatorLeft;
+    private readonly _indicatorWidth;
+    readonly indicatorStyle: _angular_core.Signal<string>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _updateIndicator;
+    selectTab(tab: NeuTab): void;
+    /** Mueve el foco entre tabs con flechas (roving tabindex — WAI-ARIA Tabs Pattern) */
+    focusTab(event: Event, dir: 1 | -1 | 'first' | 'last'): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuTabsComponent, "neu-tabs", never, { "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; "tabParam": { "alias": "tabParam"; "required": false; "isSignal": true; }; "flush": { "alias": "flush"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "tabChange": "tabChange"; }, never, ["*"], true, never>;
+}
+/**
+ * NeuralUI Tab Panel
+ *
+ * Panel de contenido asociado a una pestaña de NeuTabsComponent.
+ * Solo se renderiza (no oculta con CSS) cuando la pestaña está activa.
+ *
+ * Uso: hijo directo de <neu-tabs>
+ *   <neu-tab-panel tabId="api">...</neu-tab-panel>
+ */
+declare class NeuTabPanelComponent {
+    private readonly tabs;
+    /** ID que debe coincidir con NeuTab.id del padre */
+    tabId: _angular_core.InputSignal<string>;
+    readonly isActive: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTabPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuTabPanelComponent, "neu-tab-panel", never, { "tabId": { "alias": "tabId"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface NeuAccordionItem {
+    /** ID único del panel */
+    id: string;
+    /** Título del encabezado */
+    title: string;
+    /** Contenido del cuerpo (HTML o texto plano) */
+    content: string;
+    /** Inicia expandido */
+    expanded?: boolean;
+    /** Deshabilita este panel */
+    disabled?: boolean;
+}
+/**
+ * NeuralUI Accordion Component
+ *
+ * Paneles expandibles / colapsables con animación suave.
+ * Soporta modo múltiple (varios abiertos a la vez) o exclusivo.
+ *
+ * Uso:
+ *   <neu-accordion [items]="items" />
+ *   <neu-accordion [items]="items" [multiple]="true" />
+ */
+declare class NeuAccordionComponent {
+    private readonly _sanitizer;
+    /** Lista de paneles */
+    items: _angular_core.InputSignal<NeuAccordionItem[]>;
+    /** Permite varios paneles abiertos a la vez */
+    multiple: _angular_core.InputSignal<boolean>;
+    /** Borde exterior alrededor del accordion */
+    bordered: _angular_core.InputSignal<boolean>;
+    /** Emite el id del panel al abrirse/cerrarse */
+    panelToggle: _angular_core.OutputEmitterRef<{
+        id: string;
+        expanded: boolean;
+    }>;
+    /**
+     * Set de IDs actualmente expandidos.
+     * Se inicializa desde los ítems con `expanded: true` en el primer render.
+     * Después se vuelve un signal mutable independiente (no se resetea al cambiar items).
+     */
+    private _expandedInit;
+    private readonly _expanded;
+    constructor();
+    readonly isExpanded: (id: string) => boolean;
+    sanitize(html: string): SafeHtml;
+    toggle(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuAccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuAccordionComponent, "neu-accordion", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; }, { "panelToggle": "panelToggle"; }, never, never, true, never>;
+}
+
+type NeuCardPadding = 'none' | 'sm' | 'md' | 'lg';
+/**
+ * NeuralUI Card Component
+ *
+ * Contenedor con sombras y bordes Neural. Soporta header, body y footer
+ * via content projection.
+ *
+ * Uso:
+ *   <neu-card>
+ *     <div neu-card-header>Título</div>
+ *     <p>Contenido</p>
+ *     <div neu-card-footer>Acciones</div>
+ *   </neu-card>
+ */
+declare class NeuCardComponent {
+    /** Espaciado interior del cuerpo */
+    padding: _angular_core.InputSignal<NeuCardPadding>;
+    /** Efecto hover con elevación de sombra */
+    hoverable: _angular_core.InputSignal<boolean>;
+    /** Borde con acento de color primario */
+    bordered: _angular_core.InputSignal<boolean>;
+    /** Card compacta sin bordes ni sombras */
+    flat: _angular_core.InputSignal<boolean>;
+    readonly hostClasses: _angular_core.Signal<{
+        'neu-card': boolean;
+        'neu-card--hoverable': boolean;
+        'neu-card--bordered': boolean;
+        'neu-card--flat': boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuCardComponent, "neu-card", never, { "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "flat": { "alias": "flat"; "required": false; "isSignal": true; }; }, {}, never, ["[neu-card-header]", "*", "[neu-card-footer]"], true, never>;
+}
+
+/**
+ * NeuralUI Divider
+ *
+ * Separador visual para secciones de contenido.
+ *
+ * Uso:
+ *   <neu-divider />
+ *   <neu-divider label="O continúa con" />
+ *   <neu-divider orientation="vertical" />
+ */
+declare class NeuDividerComponent {
+    label: _angular_core.InputSignal<string>;
+    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuDividerComponent, "neu-divider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuDialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+/** Datos que se inyectan en el componente del diálogo */
+interface NeuDialogData<T = unknown> {
+    title?: string;
+    data?: T;
+}
+declare class NeuDialogService {
+    private readonly dialog;
+    open<T = unknown, R = unknown>(component: Type<unknown>, config?: {
+        title?: string;
+        data?: T;
+        size?: NeuDialogSize;
+        disableClose?: boolean;
+    }): DialogRef<R>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NeuDialogService>;
+}
+/**
+ * NeuDialogComponent — Diálogo accesible con header, body y footer.
+ * Úsalo directamente como componente declarativo pasando `open` como signal.
+ *
+ * Para uso programático, utiliza NeuDialogService.open().
+ *
+ * Uso declarativo:
+ *   <neu-dialog [open]="isOpen()" title="Editar usuario" (closed)="isOpen.set(false)">
+ *     <p>Contenido del diálogo</p>
+ *     <div neu-dialog-footer>
+ *       <neu-button (click)="save()">Guardar</neu-button>
+ *     </div>
+ *   </neu-dialog>
+ */
+declare class NeuDialogComponent {
+    /** Controla la visibilidad del diálogo. */
+    open: _angular_core.InputSignal<boolean>;
+    /** Título que aparece en el header. */
+    title: _angular_core.InputSignal<string>;
+    /** Tamaño del panel: sm | md | lg | xl | full. */
+    size: _angular_core.InputSignal<NeuDialogSize>;
+    /** Si es true, el backdrop y el botón cerrar no funcionan. */
+    disableClose: _angular_core.InputSignal<boolean>;
+    /** Emite cuando el usuario cierra el diálogo. */
+    closed: _angular_core.OutputEmitterRef<void>;
+    /** @internal — ID único para aria-labelledby */
+    readonly _uid: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuDialogComponent, "neu-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*", "[neu-dialog-footer]"], true, never>;
+}
+
+/**
+ * Directiva para definir el template de expansión de fila en NeuTable.
+ *
+ * Uso:
+ * ```html
+ * <neu-table [expandable]="true" [columns]="cols" [data]="rows">
+ *   <ng-template neuTableExpand let-row>
+ *     <div>{{ row.details }}</div>
+ *   </ng-template>
+ * </neu-table>
+ * ```
+ */
+declare class NeuTableExpandDirective {
+    readonly templateRef: TemplateRef<{
+        $implicit: Record<string, unknown>;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTableExpandDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuTableExpandDirective, "ng-template[neuTableExpand]", never, {}, {}, never, never, true, never>;
+}
+
+type NeuTableBadgeVariant = 'primary' | 'success' | 'warning' | 'danger' | 'info' | 'default';
+interface NeuTableBadgeConfig {
+    /** Etiqueta a mostrar (si omit, usa el valor bruto) */
+    label?: string;
+    variant: NeuTableBadgeVariant;
+}
+interface NeuTableColumn<T = Record<string, unknown>> {
+    /** Clave del campo en el objeto de datos */
+    key: string;
+    /** Texto del encabezado de columna */
+    header: string;
+    /** Ancho fijo (CSS: '120px', '20%', etc.) */
+    width?: string;
+    /** Alineación del contenido */
+    align?: 'left' | 'center' | 'right';
+    /** Renderer personalizado: recibe la fila completa y devuelve texto */
+    cell?: (row: T) => string;
+    /** Clases CSS adicionales para las celdas de esta columna */
+    cellClass?: string;
+    /** Esta columna es ordenable (requiere [sortable]=true en la tabla) */
+    sortable?: boolean;
+    /**
+     * Tipo de renderizado de la celda.
+     * - `'text'` (default): texto plano
+     * - `'badge'`: chip de color usando `badgeMap`
+     */
+    type?: 'text' | 'badge';
+    /**
+     * Mapa valor → configuración de badge. Requiere `type: 'badge'`.
+     * Ejemplo: `{ active: { label: 'Activo', variant: 'success' } }`
+     */
+    badgeMap?: Record<string, NeuTableBadgeConfig>;
+    /**
+     * Template personalizado para la cabecera de esta columna.
+     * Contexto de la plantilla: `{ $implicit: col }`.
+     *
+     * Ejemplo:
+     * ```html
+     * <ng-template #myHeader let-col>
+     *   <span class="custom-header">{{ col.header }}</span>
+     * </ng-template>
+     * <neu-table [columns]="[{ key: 'name', header: 'Nombre', headerTemplate: myHeader }]" ... />
+     * ```
+     */
+    headerTemplate?: TemplateRef<any>;
+}
+
+type Row = Record<string, unknown>;
+/**
+ * NeuralUI Table — Componente Estrella
+ *
+ * Tabla de datos con:
+ *   - Búsqueda/filtrado → ?q=...
+ *   - Paginación → ?page=...
+ *   - Ordenación → ?sort=col&sortDir=asc|desc
+ *   - Selección de filas (múltiple) opcional
+ *   - Skeleton de carga animado
+ *   - Scroll horizontal elegante en mobile (<400px)
+ *
+ * Uso básico:
+ *   <neu-table [columns]="cols" [data]="rows" />
+ *
+ * Múltiples tablas por página:
+ *   <neu-table pageParam="userPage" searchParam="userQ" sortParam="userSort" ... />
+ */
+declare class NeuTableComponent {
+    private readonly urlState;
+    readonly expandTemplate: _angular_core.Signal<NeuTableExpandDirective | undefined>;
+    columns: _angular_core.InputSignal<NeuTableColumn<Record<string, unknown>>[]>;
+    data: _angular_core.InputSignal<object[]>;
+    pageSize: _angular_core.InputSignal<number>;
+    loading: _angular_core.InputSignal<boolean>;
+    title: _angular_core.InputSignal<string>;
+    emptyMessage: _angular_core.InputSignal<string>;
+    skeletonRows: _angular_core.InputSignal<number[]>;
+    searchable: _angular_core.InputSignal<boolean>;
+    searchPlaceholder: _angular_core.InputSignal<string>;
+    exactMatchable: _angular_core.InputSignal<boolean>;
+    exactMatchLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del input de búsqueda */
+    searchAriaLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón de limpiar búsqueda */
+    clearSearchAriaLabel: _angular_core.InputSignal<string>;
+    /** Texto del botón que elimina el filtro activo */
+    clearFilterLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón de página anterior */
+    previousPageAriaLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón de página siguiente */
+    nextPageAriaLabel: _angular_core.InputSignal<string>;
+    sortable: _angular_core.InputSignal<boolean>;
+    selectable: _angular_core.InputSignal<boolean>;
+    expandable: _angular_core.InputSignal<boolean>;
+    exportable: _angular_core.InputSignal<boolean>;
+    exportFileName: _angular_core.InputSignal<string>;
+    pageSizeOptions: _angular_core.InputSignal<number[]>;
+    stickyHeader: _angular_core.InputSignal<boolean>;
+    /** Clave del campo que identifica de forma única cada fila */
+    rowKey: _angular_core.InputSignal<string>;
+    pageParam: _angular_core.InputSignal<string>;
+    searchParam: _angular_core.InputSignal<string>;
+    sortParam: _angular_core.InputSignal<string>;
+    sortDirParam: _angular_core.InputSignal<string>;
+    rowSelectionChange: _angular_core.OutputEmitterRef<Row[]>;
+    readonly currentPage: _angular_core.Signal<number>;
+    readonly searchQuery: _angular_core.Signal<string>;
+    readonly sortKey: _angular_core.Signal<string>;
+    readonly sortDir: _angular_core.Signal<"desc" | "asc">;
+    private readonly rows;
+    readonly exactMatch: _angular_core.WritableSignal<boolean>;
+    readonly filteredData: _angular_core.Signal<Row[]>;
+    readonly sortedData: _angular_core.Signal<Row[]>;
+    private readonly _dynamicPageSize;
+    readonly effectivePageSize: _angular_core.Signal<number>;
+    readonly totalPages: _angular_core.Signal<number>;
+    readonly paginatedData: _angular_core.Signal<Row[]>;
+    readonly pageNumbers: _angular_core.Signal<number[]>;
+    readonly paginationInfo: _angular_core.Signal<string>;
+    readonly totalColspan: _angular_core.Signal<number>;
+    private readonly _expandedKeys;
+    isRowExpanded(row: Row): boolean;
+    toggleExpand(row: Row): void;
+    private readonly _selectedKeys;
+    readonly selectedCount: _angular_core.Signal<number>;
+    readonly isAllSelected: _angular_core.Signal<boolean>;
+    readonly isSomeSelected: _angular_core.Signal<boolean>;
+    isRowSelected(row: Row): boolean;
+    toggleRow(row: Row): void;
+    toggleAll(): void;
+    clearSelection(): void;
+    private _emitSelection;
+    goToPage(page: number): void;
+    sortBy(key: string): void;
+    onSearch(event: Event): void;
+    clearSearch(): void;
+    onPageSizeChange(event: Event): void;
+    exportCsv(): void;
+    getRowKey(row: Row): unknown;
+    getCellValue(row: Row, col: NeuTableColumn): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuTableComponent, "neu-table", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "skeletonRows": { "alias": "skeletonRows"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "exactMatchable": { "alias": "exactMatchable"; "required": false; "isSignal": true; }; "exactMatchLabel": { "alias": "exactMatchLabel"; "required": false; "isSignal": true; }; "searchAriaLabel": { "alias": "searchAriaLabel"; "required": false; "isSignal": true; }; "clearSearchAriaLabel": { "alias": "clearSearchAriaLabel"; "required": false; "isSignal": true; }; "clearFilterLabel": { "alias": "clearFilterLabel"; "required": false; "isSignal": true; }; "previousPageAriaLabel": { "alias": "previousPageAriaLabel"; "required": false; "isSignal": true; }; "nextPageAriaLabel": { "alias": "nextPageAriaLabel"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "exportable": { "alias": "exportable"; "required": false; "isSignal": true; }; "exportFileName": { "alias": "exportFileName"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; "pageParam": { "alias": "pageParam"; "required": false; "isSignal": true; }; "searchParam": { "alias": "searchParam"; "required": false; "isSignal": true; }; "sortParam": { "alias": "sortParam"; "required": false; "isSignal": true; }; "sortDirParam": { "alias": "sortDirParam"; "required": false; "isSignal": true; }; }, { "rowSelectionChange": "rowSelectionChange"; }, ["expandTemplate"], never, true, never>;
+}
+
+type NeuAvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type NeuAvatarShape = 'circle' | 'square';
+type NeuAvatarColor = 'blue' | 'violet' | 'green' | 'amber' | 'red' | 'slate';
+type NeuAvatarStatus = 'online' | 'offline' | 'busy' | 'away' | '';
+/**
+ * NeuAvatar — Avatar circular o cuadrado para foto o iniciales.
+ *
+ * Uso:
+ *   <neu-avatar name="Pedro Moreno" />
+ *   <neu-avatar src="/assets/avatar.jpg" alt="Pedro" size="lg" />
+ *   <neu-avatar name="PM" size="lg" color="blue" status="online" />
+ */
+declare class NeuAvatarComponent {
+    /** URL de la imagen. Si falla la carga, muestra las iniciales. */
+    src: _angular_core.InputSignal<string>;
+    /** Texto alternativo de la imagen. */
+    alt: _angular_core.InputSignal<string>;
+    /** Nombre completo — se usan las iniciales como fallback. */
+    name: _angular_core.InputSignal<string>;
+    /** Tamaño: xs (24) | sm (32) | md (40) | lg (48) | xl (64). Por defecto 'md'. */
+    size: _angular_core.InputSignal<NeuAvatarSize>;
+    /** Forma: 'circle' (default) o 'square'. */
+    shape: _angular_core.InputSignal<NeuAvatarShape>;
+    /** Color de fondo para iniciales. */
+    color: _angular_core.InputSignal<NeuAvatarColor>;
+    /** Indicador de presencia. */
+    status: _angular_core.InputSignal<NeuAvatarStatus>;
+    /** @internal Imagen fallida */
+    protected readonly imgError: _angular_core.WritableSignal<boolean>;
+    protected readonly initials: _angular_core.Signal<string>;
+    protected readonly hostClasses: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuAvatarComponent, "neu-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuBadgeVariant = 'default' | 'success' | 'info' | 'warning' | 'danger';
+type NeuBadgeSize = 'sm' | 'md';
+/**
+ * NeuralUI Badge Component
+ *
+ * Etiqueta de estado compacta y semántica.
+ *
+ * Uso: <neu-badge variant="success">Activo</neu-badge>
+ *      <neu-badge variant="danger" [dot]="true">Error</neu-badge>
+ */
+declare class NeuBadgeComponent {
+    /** Variante semántica */
+    variant: _angular_core.InputSignal<NeuBadgeVariant>;
+    /** Tamaño */
+    size: _angular_core.InputSignal<NeuBadgeSize>;
+    /** Muestra un punto de color a la izquierda */
+    dot: _angular_core.InputSignal<boolean>;
+    /** Estilo con solo borde (outline) sin relleno */
+    outline: _angular_core.InputSignal<boolean>;
+    /** Estilo completamente redondeado (pill) */
+    pill: _angular_core.InputSignal<boolean>;
+    readonly hostClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        'neu-badge': boolean;
+        'neu-badge--outline': boolean;
+        'neu-badge--pill': boolean;
+        'neu-badge--dot': boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuBadgeComponent, "neu-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "pill": { "alias": "pill"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type NeuChartType = 'line' | 'area' | 'bar' | 'bar-stacked' | 'bar-horizontal' | 'bar-horizontal-stacked' | 'pareto' | 'donut' | 'pie' | 'radialBar';
+interface NeuChartSeries {
+    name: string;
+    data: number[];
+}
+/**
+ * NeuChart — Wrapper reactivo de ApexCharts con estética Neural-Blue.
+ *
+ * Tipos soportados:
+ *   line · area · bar · bar-stacked · bar-horizontal · bar-horizontal-stacked · pareto · donut · pie · radialBar
+ *
+ * Uso:
+ *   <neu-chart
+ *     type="bar-stacked"
+ *     [series]="series()"
+ *     [categories]="months()"
+ *     height="280"
+ *   />
+ */
+declare class NeuChartComponent {
+    /** Tipo de gráfica. */
+    type: _angular_core.InputSignal<NeuChartType>;
+    /** Series para gráficas de ejes (line, area, bar, pareto…). */
+    series: _angular_core.InputSignal<NeuChartSeries[]>;
+    /** Series para gráficas sin ejes (donut, pie). */
+    pieSeries: _angular_core.InputSignal<number[]>;
+    /** Etiquetas del eje X. */
+    categories: _angular_core.InputSignal<string[]>;
+    /** Etiquetas para donut/pie. */
+    labels: _angular_core.InputSignal<string[]>;
+    /** Altura en px. */
+    height: _angular_core.InputSignal<number>;
+    /** Colores custom. Si no se proveen, usa la paleta Neural-Blue. */
+    colors: _angular_core.InputSignal<string[]>;
+    /** Muestra/oculta las etiquetas de datos. */
+    showDataLabels: _angular_core.InputSignal<boolean>;
+    /** Título de la gráfica. */
+    title: _angular_core.InputSignal<string>;
+    private get _isBar();
+    private get _isStacked();
+    private get _isHorizontal();
+    protected readonly resolvedColors: _angular_core.Signal<string[]>;
+    protected readonly resolvedSeries: _angular_core.Signal<any>;
+    protected readonly chartConfig: _angular_core.Signal<{
+        type: any;
+        height: number;
+        stacked: boolean;
+        fontFamily: string;
+        foreColor: string;
+        background: string;
+        toolbar: {
+            show: boolean;
+        };
+        sparkline: {
+            enabled: boolean;
+        };
+        zoom: {
+            enabled: boolean;
+        };
+        animations: {
+            enabled: boolean;
+            speed: number;
+        };
+    }>;
+    protected readonly xaxisConfig: _angular_core.Signal<{
+        categories: string[];
+        labels: {
+            style: {
+                fontSize: string;
+                fontFamily: string;
+                colors: string;
+            };
+        };
+        axisBorder: {
+            show: boolean;
+        };
+        axisTicks: {
+            show: boolean;
+        };
+    }>;
+    protected readonly yaxisConfig: _angular_core.Signal<any>;
+    protected readonly strokeConfig: _angular_core.Signal<{
+        show: boolean;
+        width?: undefined;
+        curve?: undefined;
+        lineCap?: undefined;
+    } | {
+        show: boolean;
+        width: number[];
+        curve: any;
+        lineCap: "round";
+    } | {
+        curve: "smooth";
+        width: number;
+        show?: undefined;
+        lineCap?: undefined;
+    }>;
+    protected readonly fillConfig: _angular_core.Signal<{
+        type: "gradient";
+        gradient: {
+            shadeIntensity: number;
+            opacityFrom: number;
+            opacityTo: number;
+            stops: number[];
+        };
+        opacity?: undefined;
+    } | {
+        opacity: number;
+        type?: undefined;
+        gradient?: undefined;
+    }>;
+    protected readonly dataLabelsConfig: _angular_core.Signal<{
+        enabled: boolean;
+        style: {
+            fontSize: string;
+            fontFamily: string;
+        };
+    }>;
+    protected readonly gridConfig: _angular_core.Signal<{
+        borderColor: string;
+        strokeDashArray: number;
+        xaxis: {
+            lines: {
+                show: boolean;
+            };
+        };
+        yaxis: {
+            lines: {
+                show: boolean;
+            };
+        };
+        padding: {
+            left: number;
+            right: number;
+        };
+    }>;
+    protected readonly legendConfig: _angular_core.Signal<{
+        position: "bottom";
+        fontFamily: string;
+        fontSize: string;
+        markers: {
+            size: number;
+        };
+        itemMargin: {
+            horizontal: number;
+        };
+    }>;
+    protected readonly tooltipConfig: _angular_core.Signal<{
+        theme: "light";
+        style: {
+            fontSize: string;
+            fontFamily: string;
+        };
+    } | {
+        y: {
+            formatter: (v: number) => string;
+        }[];
+        theme: "light";
+        style: {
+            fontSize: string;
+            fontFamily: string;
+        };
+    }>;
+    protected readonly plotOptionsConfig: _angular_core.Signal<{
+        pie: {
+            donut: {
+                size: string;
+            };
+        };
+        bar?: undefined;
+    } | {
+        bar: {
+            horizontal: boolean;
+            borderRadius: number;
+            columnWidth: string;
+            barHeight: string;
+            dataLabels: {
+                total: {
+                    enabled: boolean;
+                };
+            };
+        };
+        pie?: undefined;
+    } | {
+        pie?: undefined;
+        bar?: undefined;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuChartComponent, "neu-chart", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "pieSeries": { "alias": "pieSeries"; "required": false; "isSignal": true; }; "categories": { "alias": "categories"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "showDataLabels": { "alias": "showDataLabels"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuChipVariant = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+type NeuChipSize = 'sm' | 'md';
+/**
+ * NeuralUI Chip Component
+ *
+ * Etiqueta compacta seleccionable y/o eliminable. Ideal para filtros,
+ * listas de tags y multiselección visual.
+ *
+ * Uso:
+ *   <neu-chip>Angular</neu-chip>
+ *   <neu-chip [removable]="true" (removed)="onRemove()">CSS</neu-chip>
+ *   <neu-chip [selected]="true" (selectedChange)="toggle()">TypeScript</neu-chip>
+ */
+declare class NeuChipComponent {
+    /** Variante de color */
+    variant: _angular_core.InputSignal<NeuChipVariant>;
+    /** Tamaño */
+    size: _angular_core.InputSignal<NeuChipSize>;
+    /** Estado seleccionado */
+    selected: _angular_core.InputSignal<boolean>;
+    /** Muestra botón de cierre */
+    removable: _angular_core.InputSignal<boolean>;
+    /** Deshabilitado */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Aria-label del botón de eliminar */
+    removeAriaLabel: _angular_core.InputSignal<string>;
+    /** Emite al hacer clic o pulsar espacio/enter */
+    selectedChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Emite al pulsar el botón de cierre */
+    removed: _angular_core.OutputEmitterRef<void>;
+    readonly hostClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        'neu-chip': boolean;
+        'neu-chip--selected': boolean;
+        'neu-chip--removable': boolean;
+        'neu-chip--disabled': boolean;
+    }>;
+    onToggle(): void;
+    onRemove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuChipComponent, "neu-chip", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "removeAriaLabel": { "alias": "removeAriaLabel"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; "removed": "removed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * NeuralUI Code Block
+ *
+ * Bloque de código con estilo editor oscuro (Tokyo Night).
+ * Incluye botón de copiar al portapapeles, badge del lenguaje
+ * y soporte para resaltado futuro con ngx-highlightjs.
+ *
+ * Uso:
+ *   <neu-code-block [code]="snippet" lang="TypeScript" />
+ *
+ * Con ngx-highlightjs instalado, envuelve el <pre> con
+ *   [highlight]="code" para resaltado automático.
+ */
+declare class NeuCodeBlockComponent {
+    private readonly doc;
+    /** Código fuente a mostrar */
+    code: _angular_core.InputSignal<string>;
+    /** Nombre del lenguaje (decorativo) */
+    lang: _angular_core.InputSignal<string>;
+    /** Texto del botón cuando no se ha copiado */
+    copyLabel: _angular_core.InputSignal<string>;
+    /** Texto del botón tras copiar */
+    copiedLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón copiar */
+    copyAriaLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón tras copiar */
+    copiedAriaLabel: _angular_core.InputSignal<string>;
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
+    private _copyTimer?;
+    copy(): void;
+    private _markCopied;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuCodeBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuCodeBlockComponent, "neu-code-block", never, { "code": { "alias": "code"; "required": false; "isSignal": true; }; "lang": { "alias": "lang"; "required": false; "isSignal": true; }; "copyLabel": { "alias": "copyLabel"; "required": false; "isSignal": true; }; "copiedLabel": { "alias": "copiedLabel"; "required": false; "isSignal": true; }; "copyAriaLabel": { "alias": "copyAriaLabel"; "required": false; "isSignal": true; }; "copiedAriaLabel": { "alias": "copiedAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * NeuEmptyState — Estado vacío con icono Lucide, título, descripción y acción.
+ *
+ * Uso:
+ *   <neu-empty-state
+ *     icon="lucideInbox"
+ *     title="Sin resultados"
+ *     description="Prueba con otros filtros."
+ *     actionLabel="Limpiar filtros"
+ *     (action)="clearFilters()"
+ *   />
+ */
+declare class NeuEmptyStateComponent {
+    /** Nombre del icono Lucide registrado con provideIcons(). */
+    icon: _angular_core.InputSignal<string>;
+    /** Tamaño del icono. Por defecto 3rem. */
+    iconSize: _angular_core.InputSignal<string>;
+    /** Título principal del estado vacío. */
+    title: _angular_core.InputSignal<string>;
+    /** Descripción secundaria opcional. */
+    description: _angular_core.InputSignal<string>;
+    /** Texto del botón de acción. Si está vacío, no se muestra el botón. */
+    actionLabel: _angular_core.InputSignal<string>;
+    /** Emite cuando el usuario hace clic en el botón de acción. */
+    action: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuEmptyStateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuEmptyStateComponent, "neu-empty-state", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "actionLabel": { "alias": "actionLabel"; "required": false; "isSignal": true; }; }, { "action": "action"; }, never, never, true, never>;
+}
+
+/**
+ * NeuIconComponent — Wrapper delgado sobre NgIcon de @ng-icons/core
+ *
+ * Hereda el color del elemento padre mediante `color: currentColor`.
+ * El grosor del trazo se controla con la variable CSS `--ng-icon__stroke-width`
+ * que viene configurada globalmente vía `provideNgIconsConfig`.
+ *
+ * Uso básico:
+ *   <neu-icon name="lucideX" />
+ *   <neu-icon name="lucideAlertCircle" size="1rem" />
+ */
+declare class NeuIconComponent {
+    /** Nombre del icono registrado con provideIcons() */
+    name: _angular_core.InputSignal<string>;
+    /**
+     * Grosor del trazo. Default '2' para estética fina y técnica.
+     * Puede sobrescribirse por instancia.
+     */
+    strokeWidth: _angular_core.InputSignal<string>;
+    /**
+     * Tamaño del icono. Acepta cualquier unidad CSS válida.
+     * Si no se especifica, usa la variable CSS `--neu-icon-size` (1.25rem por defecto).
+     */
+    size: _angular_core.InputSignal<string>;
+    /** Tamaño resuelto: usa el input `size` o cae al token CSS. */
+    readonly resolvedSize: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuIconComponent, "neu-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuProgressVariant = 'primary' | 'success' | 'warning' | 'danger';
+/**
+ * NeuralUI ProgressBar Component
+ *
+ * Barra de progreso accesible con valor, etiqueta y variantes semánticas.
+ * Soporte para modo indeterminado (animación continua).
+ *
+ * Uso:
+ *   <neu-progress-bar [value]="75" />
+ *   <neu-progress-bar [value]="75" label="Cargando..." variant="success" [showValue]="true" />
+ *   <neu-progress-bar [indeterminate]="true" />
+ */
+declare class NeuProgressBarComponent {
+    /** Valor de 0 a 100 */
+    value: _angular_core.InputSignal<number>;
+    /** Variante de color */
+    variant: _angular_core.InputSignal<NeuProgressVariant>;
+    /** Etiqueta descriptiva sobre la barra */
+    label: _angular_core.InputSignal<string>;
+    /** Muestra el % a la derecha */
+    showValue: _angular_core.InputSignal<boolean>;
+    /** Modo indeterminado (animación continua) */
+    indeterminate: _angular_core.InputSignal<boolean>;
+    /** Altura de la barra */
+    size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly clampedValue: _angular_core.Signal<number>;
+    readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuProgressBarComponent, "neu-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Rating Component
+ *
+ * Selector de valoración con estrellas (o icono personalizable).
+ * Soporta valores medios (half-star) y modo solo-lectura.
+ *
+ * Uso:
+ *   <neu-rating [value]="rating" (valueChange)="rating = $event" />
+ *   <neu-rating [value]="4.5" [readonly]="true" />
+ */
+declare class NeuRatingComponent {
+    protected readonly Math: Math;
+    /** Valor actual (1 a stars) */
+    value: _angular_core.InputSignal<number>;
+    /** Número de estrellas */
+    stars: _angular_core.InputSignal<number>;
+    /** Modo solo lectura */
+    readonly: _angular_core.InputSignal<boolean>;
+    /** Emite el nuevo valor al seleccionar */
+    valueChange: _angular_core.OutputEmitterRef<number>;
+    protected readonly hovered: _angular_core.WritableSignal<number | null>;
+    readonly starsArray: _angular_core.Signal<number[]>;
+    onHover(i: number): void;
+    onLeave(): void;
+    select(i: number): void;
+    isInteger(n: number): boolean;
+    getFill(i: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuRatingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuRatingComponent, "neu-rating", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "stars": { "alias": "stars"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Skeleton Component
+ *
+ * Placeholder animado para simular la carga de contenido.
+ *
+ * Uso:
+ *   <neu-skeleton width="100%" height="20px" />
+ *   <neu-skeleton variant="circle" width="40px" height="40px" />
+ *   <neu-skeleton variant="text" />
+ */
+declare class NeuSkeletonComponent {
+    readonly variant: _angular_core.InputSignal<"text" | "circle" | "rect">;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly borderRadius: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuSkeletonComponent, "neu-skeleton", never, { "variant": { "alias": "variant"; "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>;
+}
+
+type NeuSpinnerSeverity = 'primary' | 'success' | 'warning' | 'danger' | 'info';
+/**
+ * NeuralUI Spinner Component
+ *
+ * Indicador de carga circular animado, similar al ProgressSpinner de PrimeNG.
+ * Permite personalizar color via severity o color CSS directo.
+ *
+ * Uso básico:
+ *   <neu-spinner />
+ *
+ * Con severity:
+ *   <neu-spinner severity="success" size="48px" />
+ *
+ * Con color personalizado:
+ *   <neu-spinner color="#ff6b35" strokeWidth="6" />
+ */
+declare class NeuSpinnerComponent {
+    /** Variante de color semántica */
+    severity: _angular_core.InputSignal<NeuSpinnerSeverity>;
+    /** Color CSS directo — sobreescribe severity */
+    color: _angular_core.InputSignal<string>;
+    /** Grosor del trazo SVG (unidades SVG) */
+    strokeWidth: _angular_core.InputSignal<string>;
+    /** Tamaño del spinner (CSS: '40px', '2rem', etc.) */
+    size: _angular_core.InputSignal<string>;
+    /** Duración de la animación de rotación */
+    animationDuration: _angular_core.InputSignal<string>;
+    /** Texto accesible para lectores de pantalla */
+    ariaLabel: _angular_core.InputSignal<string>;
+    readonly _severityColor: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuSpinnerComponent, "neu-spinner", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NeuSplitButtonAction {
+    /** Identificador único de la acción */
+    id: string;
+    /** Texto visible */
+    label: string;
+    /** Icono opcional (SVG string o nombre) */
+    icon?: string;
+    /** Deshabilita esta acción individualmente */
+    disabled?: boolean;
+    /** Separador visual encima de este item */
+    divider?: boolean;
+}
+/**
+ * NeuralUI SplitButton Component
+ *
+ * Botón principal con un dropdown de acciones adicionales.
+ *
+ * Uso:
+ *   <neu-split-button
+ *     label="Guardar"
+ *     [actions]="actions"
+ *     (primaryClick)="save()"
+ *     (actionClick)="onAction($event)"
+ *   />
+ */
+declare class NeuSplitButtonComponent {
+    private readonly el;
+    /** Texto del botón principal */
+    label: _angular_core.InputSignal<string>;
+    /** Variante visual */
+    variant: _angular_core.InputSignal<NeuButtonVariant>;
+    /** Tamaño */
+    size: _angular_core.InputSignal<NeuButtonSize>;
+    /** Deshabilita todo el componente */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Muestra spinner en el botón principal */
+    loading: _angular_core.InputSignal<boolean>;
+    /** Acciones del dropdown */
+    actions: _angular_core.InputSignal<NeuSplitButtonAction[]>;
+    /** Aria-label del botón de desplegable */
+    moreActionsAriaLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del menú desplegable */
+    actionsAriaLabel: _angular_core.InputSignal<string>;
+    /** Emite al hacer click en el botón principal */
+    primaryClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** Emite al seleccionar una acción del dropdown */
+    actionClick: _angular_core.OutputEmitterRef<NeuSplitButtonAction>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    readonly mainClasses: _angular_core.Signal<string>;
+    readonly chevronClasses: _angular_core.Signal<string>;
+    toggleDropdown(event: MouseEvent): void;
+    closeDropdown(): void;
+    onDocumentClick(event: MouseEvent): void;
+    onPrimaryClick(event: MouseEvent): void;
+    onActionClick(action: NeuSplitButtonAction): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuSplitButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuSplitButtonComponent, "neu-split-button", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "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; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "moreActionsAriaLabel": { "alias": "moreActionsAriaLabel"; "required": false; "isSignal": true; }; "actionsAriaLabel": { "alias": "actionsAriaLabel"; "required": false; "isSignal": true; }; }, { "primaryClick": "primaryClick"; "actionClick": "actionClick"; }, never, never, true, never>;
+}
+
+type NeuStatsTrend = 'up' | 'down' | 'neutral';
+/**
+ * NeuStatsCard — Card de métrica con título, valor, tendencia y sparkline.
+ *
+ * Uso:
+ *   <neu-stats-card
+ *     title="Ingresos"
+ *     value="$12,450"
+ *     change="+12.5%"
+ *     trend="up"
+ *     icon="lucideDollarSign"
+ *     [sparkData]="[30,45,38,52,60,55,70]"
+ *   />
+ */
+declare class NeuStatsCardComponent {
+    /** Título o etiqueta de la métrica. */
+    title: _angular_core.InputSignal<string>;
+    /** Valor principal formateado (p.ej. "$12,450" o "98.2%"). */
+    value: _angular_core.InputSignal<string>;
+    /** Cambio porcentual o absoluto (p.ej. "+12.5%" o "-3"). */
+    change: _angular_core.InputSignal<string>;
+    /** Dirección del cambio. Afecta el color del change. */
+    trend: _angular_core.InputSignal<NeuStatsTrend>;
+    /** Texto auxiliar bajo el cambio (p.ej. "vs. mes anterior"). */
+    label: _angular_core.InputSignal<string>;
+    /** Nombre del icono Lucide para el encabezado. */
+    icon: _angular_core.InputSignal<string>;
+    /** Array de valores numéricos para la sparkline. Mín. 2 puntos. */
+    sparkData: _angular_core.InputSignal<number[]>;
+    /** @internal Genera los puntos SVG de la sparkline */
+    protected readonly sparkPoints: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuStatsCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuStatsCardComponent, "neu-stats-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "change": { "alias": "change"; "required": false; "isSignal": true; }; "trend": { "alias": "trend"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "sparkData": { "alias": "sparkData"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuTimelineItemVariant = 'default' | 'success' | 'warning' | 'danger' | 'info';
+interface NeuTimelineItem {
+    /** Etiqueta de tiempo (ej. "Hace 2h", "12 Mar") */
+    time?: string;
+    /** Título del evento */
+    title: string;
+    /** Descripción opcional */
+    description?: string;
+    /** Variante de color del punto */
+    variant?: NeuTimelineItemVariant;
+    /** Icono SVG path opcional */
+    icon?: string;
+}
+/**
+ * NeuralUI Timeline Component
+ *
+ * Lista vertical de eventos cronológicos con línea conectora.
+ *
+ * Uso:
+ *   <neu-timeline [items]="events" />
+ *   <neu-timeline [items]="events" align="right" />
+ */
+declare class NeuTimelineComponent {
+    /** Eventos a mostrar */
+    items: _angular_core.InputSignal<NeuTimelineItem[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuTimelineComponent, "neu-timeline", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * NeuralUI Toast Container Component
+ *
+ * Renderiza los toasts activos del NeuToastService.
+ * Añade este componente una sola vez en la raíz del app (app.html).
+ *
+ * Diseño mobile-first:
+ *   - < 400px: banner inferior centrado
+ *   - ≥ 400px: stack en la esquina superior derecha
+ *
+ * Uso:
+ *   <!-- en app.html -->
+ *   <neu-toast-container />
+ */
+declare class NeuToastContainerComponent {
+    readonly toastService: NeuToastService;
+    getIcon(type: NeuToastType): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuToastContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuToastContainerComponent, "neu-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+/** @internal — componente flotante del tooltip, renderizado vía CDK Portal */
+declare class NeuTooltipOverlayComponent {
+    readonly text: _angular_core.InputSignal<string>;
+    readonly tooltipId: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTooltipOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuTooltipOverlayComponent, "neu-tooltip-overlay", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "tooltipId": { "alias": "tooltipId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * NeuralUI Tooltip Directive
+ *
+ * Muestra un globo informativo al hacer hover/focus sobre el elemento host.
+ * Usa CDK Overlay para posicionamiento robusto.
+ *
+ * Uso:
+ *   <button [neuTooltip]="'Guardar cambios'">Guardar</button>
+ *   <button [neuTooltip]="'Eliminar'" neuTooltipPosition="bottom">Eliminar</button>
+ */
+declare class NeuTooltipDirective implements OnDestroy {
+    readonly neuTooltip: _angular_core.InputSignal<string>;
+    readonly neuTooltipPosition: _angular_core.InputSignal<NeuTooltipPosition>;
+    readonly neuTooltipDisabled: _angular_core.InputSignal<boolean>;
+    private readonly _overlay;
+    private readonly _elementRef;
+    private readonly _injector;
+    readonly _tooltipId: string;
+    /** Elementos HTML nativamente focusables que no necesitan tabindex extra */
+    private readonly _NATIVE_FOCUSABLE;
+    protected readonly _needsTabindex: () => boolean;
+    private _overlayRef;
+    private _tooltipRef;
+    private _hideTimeout;
+    show(): void;
+    hide(): void;
+    private _createOverlay;
+    private _getPositions;
+    private _detach;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuTooltipDirective, "[neuTooltip]", never, { "neuTooltip": { "alias": "neuTooltip"; "required": true; "isSignal": true; }; "neuTooltipPosition": { "alias": "neuTooltipPosition"; "required": false; "isSignal": true; }; "neuTooltipDisabled": { "alias": "neuTooltipDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NEU_RADIO_GROUP, NEU_TABS_CONTEXT, NeuAccordionComponent, NeuAvatarComponent, NeuBadgeComponent, NeuBreadcrumbComponent, NeuButtonComponent, NeuCardComponent, NeuChartComponent, NeuCheckboxComponent, NeuChipComponent, NeuCodeBlockComponent, NeuDateInputComponent, NeuDialogComponent, NeuDialogService, NeuDividerComponent, NeuEmptyStateComponent, NeuIconComponent, NeuInputComponent, NeuMultiselectComponent, NeuMultiselectItemDirective, NeuNavComponent, NeuPaginationComponent, NeuProgressBarComponent, NeuRadioComponent, NeuRadioGroupComponent, NeuRatingComponent, NeuSelectComponent, NeuSelectItemDirective, NeuSelectSelectedDirective, NeuSidebarComponent, NeuSkeletonComponent, NeuSliderComponent, NeuSpinnerComponent, NeuSplitButtonComponent, NeuStatsCardComponent, NeuStepperComponent, NeuSwitchComponent, NeuTabPanelComponent, NeuTableComponent, NeuTableExpandDirective, NeuTabsComponent, NeuTextareaComponent, NeuTimelineComponent, NeuToastContainerComponent, NeuToastService, NeuToggleButtonGroupComponent, NeuTooltipDirective, NeuTooltipOverlayComponent, NeuUrlStateService, provideNeuralUI };
+export type { NeuAccordionItem, NeuAvatarColor, NeuAvatarShape, NeuAvatarSize, NeuAvatarStatus, NeuBadgeSize, NeuBadgeVariant, NeuBreadcrumbItem, NeuButtonIconPosition, NeuButtonSize, NeuButtonVariant, NeuCardPadding, NeuChartSeries, NeuChartType, NeuChipSize, NeuChipVariant, NeuDialogData, NeuDialogSize, NeuInputType, NeuNavItem, NeuProgressVariant, NeuSelectGroup, NeuSelectOption, NeuSpinnerSeverity, NeuSplitButtonAction, NeuStatsTrend, NeuStepperStep, NeuTab, NeuTableBadgeConfig, NeuTableBadgeVariant, NeuTableColumn, NeuTimelineItem, NeuTimelineItemVariant, NeuToastItem, NeuToastOptions, NeuToastPosition, NeuToastType, NeuToggleOption, NeuTooltipPosition, NeuralUIConfig };