@neural-ui/core 1.2.1 → 1.3.1

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

@@ -0,0 +1,68 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * NeuralUI Knob Component
+ *
+ * Control de dial rotatorio para selección de valores numéricos. Implementa CVA.
+ *
+ * Uso: <neu-knob [min]="0" [max]="100" formControlName="volume" />
+ */
+declare class NeuKnobComponent implements ControlValueAccessor {
+    /** Valor mínimo / Min value */
+    readonly min: _angular_core.InputSignal<number>;
+    /** Valor máximo / Max value */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Incremento por paso / Step increment */
+    readonly step: _angular_core.InputSignal<number>;
+    /** Tamaño del dial en px / Dial size in px */
+    readonly size: _angular_core.InputSignal<number>;
+    /** Muestra el valor numérico en el centro / Shows the numeric value in the center */
+    readonly showValue: _angular_core.InputSignal<boolean>;
+    /** Etiqueta visible / Visible label */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Emitido en cada cambio / Emitted on each change */
+    readonly valueChange: _angular_core.OutputEmitterRef<number>;
+    readonly _id: string;
+    readonly _cvaDisabled: _angular_core.WritableSignal<boolean>;
+    readonly _value: _angular_core.WritableSignal<number>;
+    readonly _strokeWidth: _angular_core.Signal<number>;
+    readonly _radius: _angular_core.Signal<number>;
+    readonly _circumference: _angular_core.Signal<number>;
+    /** Arc spans 260° (from -40° to 220°) */
+    readonly _arcLength: _angular_core.Signal<number>;
+    readonly _normalizedValue: _angular_core.Signal<number>;
+    readonly _arcDashArray: _angular_core.Signal<string>;
+    readonly _arcDashOffset: _angular_core.Signal<number>;
+    readonly _indicatorAngle: _angular_core.Signal<number>;
+    readonly _indicatorX: _angular_core.Signal<number>;
+    readonly _indicatorY: _angular_core.Signal<number>;
+    private _dragStartAngle;
+    private _dragStartValue;
+    private _onChange;
+    private _onTouched;
+    private readonly _el;
+    /** Calcula el ángulo en grados desde el centro del dial al punto (x, y).
+     *  Calculates the angle in degrees from the dial center to point (x, y). */
+    private _getAngle;
+    readonly hostClasses: _angular_core.Signal<{
+        'neu-knob': boolean;
+        'neu-knob--disabled': boolean;
+    }>;
+    writeValue(val: number | null): void;
+    registerOnChange(fn: (v: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    onMouseDown(event: MouseEvent): void;
+    onTouchStart(event: TouchEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    /** Aplica el drag circular calculando el delta de ángulo respecto al punto inicial.
+     *  Applies circular drag by computing the angle delta from the start point. */
+    private _applyCircularDrag;
+    private _emit;
+    private _clamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuKnobComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuKnobComponent, "neu-knob", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { NeuKnobComponent };

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

@@ -0,0 +1,52 @@
+import * as _angular_core from '@angular/core';
+
+interface NeuMeterItem {
+    /** Etiqueta del segmento / Segment label */
+    label: string;
+    /** Valor numérico del segmento / Numeric value of the segment */
+    value: number;
+    /** Color CSS opcional / Optional CSS color */
+    color?: string;
+}
+/**
+ * NeuralUI MeterGroup Component
+ *
+ * Barra de progreso multi-segmento que muestra la distribución de valores.
+ *
+ * Uso:
+ *   <neu-meter-group [items]="meters" [total]="100" />
+ */
+declare class NeuMeterGroupComponent {
+    /** Segmentos del medidor / Meter segments */
+    readonly items: _angular_core.InputSignal<NeuMeterItem[]>;
+    /** Total de referencia (0 = suma de items) / Reference total (0 = sum of items) */
+    readonly total: _angular_core.InputSignal<number>;
+    /** Altura de la barra en px / Bar height in px */
+    readonly height: _angular_core.InputSignal<number>;
+    /** Esquinas redondeadas / Rounded corners */
+    readonly rounded: _angular_core.InputSignal<boolean>;
+    /** Muestra leyenda debajo / Shows legend below */
+    readonly showLegend: _angular_core.InputSignal<boolean>;
+    /** Aria-label de la barra / Aria-label for the bar */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly hostClasses: _angular_core.Signal<{
+        'neu-meter-group': boolean;
+        'neu-meter-group--rounded': boolean;
+    }>;
+    readonly _usedSum: _angular_core.Signal<number>;
+    readonly _effectiveTotal: _angular_core.Signal<number>;
+    readonly _segments: _angular_core.Signal<{
+        pct: number;
+        /** Etiqueta del segmento / Segment label */
+        label: string;
+        /** Valor numérico del segmento / Numeric value of the segment */
+        value: number;
+        /** Color CSS opcional / Optional CSS color */
+        color?: string;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuMeterGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuMeterGroupComponent, "neu-meter-group", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NeuMeterGroupComponent };
+export type { NeuMeterItem };

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

@@ -0,0 +1,54 @@
+import * as _angular_core from '@angular/core';
+import { Type } from '@angular/core';
+import { DialogRef } from '@angular/cdk/dialog';
+
+type NeuDialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+/** Datos que se inyectan en el componente del diálogo / Data injected into the dialog component */
+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. / Accessible dialog with header, body and footer.
+ * Úsalo directamente como componente declarativo pasando `open` como signal. / Use it directly as a declarative component passing `open` as a 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. / Controls dialog visibility. */
+    open: _angular_core.InputSignal<boolean>;
+    /** Título que aparece en el header. / Title shown in the header. */
+    title: _angular_core.InputSignal<string>;
+    /** Tamaño del panel: sm | md | lg | xl | full. / Panel size: sm | md | lg | xl | full. */
+    size: _angular_core.InputSignal<NeuDialogSize>;
+    /** Si es true, el backdrop y el botón cerrar no funcionan. / If true, the backdrop and close button do not work. */
+    disableClose: _angular_core.InputSignal<boolean>;
+    /** Emite cuando el usuario cierra el diálogo. / Emits when the user closes the dialog. */
+    closed: _angular_core.OutputEmitterRef<void>;
+    /** @internal — ID único para aria-labelledby / Unique ID for 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>;
+}
+
+export { NeuDialogComponent, NeuDialogService };
+export type { NeuDialogData, NeuDialogSize };

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

@@ -0,0 +1,138 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Signal } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { NeuSelectOption } from '@neural-ui/core/select';
+export { NeuSelectOption } from '@neural-ui/core/select';
+
+/**
+ * Directiva para personalizar el template de cada ítem del dropdown de Multiselect. / Directive to customize the template of each Multiselect dropdown item.
+ *
+ * Uso:
+ * ```html
+ * <neu-multiselect [options]="opts" [formControl]="valuesCtrl">
+ *   <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 / Multiple selection dropdown with chips, integrated search and support
+ * para ControlValueAccessor y Reactive Forms. Puede usarse dentro de un FormGroup o con un FormControl standalone. / for ControlValueAccessor and Reactive Forms. It can be used inside a FormGroup or with a standalone FormControl.
+ *
+ * Uso:
+ *   readonly technologiesCtrl = new FormControl<string[]>([], { nonNullable: true });
+ *   <neu-multiselect label="Tecnologías" [options]="opts" [formControl]="technologiesCtrl" />
+ */
+declare class NeuMultiselectComponent implements ControlValueAccessor {
+    private readonly elementRef;
+    private readonly _urlState;
+    private readonly _mobileViewportMax;
+    private readonly _viewportMargin;
+    private readonly _urlParamSignals;
+    private _getUrlParamSignal;
+    constructor();
+    /** @internal */
+    readonly _triggerId: string;
+    readonly _panelId: string;
+    /** Template personalizado para cada opción del dropdown / Custom template for each dropdown option */
+    readonly itemTpl: Signal<NeuMultiselectItemDirective | undefined>;
+    /** Opciones del dropdown / Dropdown options */
+    options: _angular_core.InputSignal<NeuSelectOption[]>;
+    /** Etiqueta del componente / Component label */
+    label: _angular_core.InputSignal<string>;
+    /** Muestra el label como flotante dentro del campo (true) o estático encima (false) / Shows the label as floating inside the field (true) or static above (false) */
+    floatingLabel: _angular_core.InputSignal<boolean>;
+    /** Tamaño del campo: 'sm' = 36px | 'md' = 48px | 'lg' = 56px / Field size */
+    size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Placeholder cuando no hay selección / Placeholder when there is no selection */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Mensaje de error / Error message */
+    errorMessage: _angular_core.InputSignal<string>;
+    /** Texto de ayuda bajo el campo / Helper text below the field */
+    hint: _angular_core.InputSignal<string>;
+    /** Deshabilita el componente / Disables the component */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Activa input de búsqueda/filtro en el panel / Activates the search/filter input in the panel */
+    searchable: _angular_core.InputSignal<boolean>;
+    /** Placeholder del input de búsqueda / Search input placeholder */
+    searchPlaceholder: _angular_core.InputSignal<string>;
+    /** Texto cuando no hay opciones tras filtrar / Text when no options remain after filtering */
+    noResultsMessage: _angular_core.InputSignal<string>;
+    /** Texto del botón de limpiar todas las selecciones / Button text to clear all selections */
+    clearAllLabel: _angular_core.InputSignal<string>;
+    /** Muestra un botón × en el trigger para limpiar la selección de una vez / Shows a × button in the trigger to clear the selection at once */
+    clearable: _angular_core.InputSignal<boolean>;
+    /** Aria-label del botón clear que aparece en el trigger / Aria-label for the clear button shown in the trigger */
+    clearAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Sincroniza los valores seleccionados con este query param de la URL.
+     * Los valores se codifican como lista separada por comas: `?{urlParam}=a,b,c`.
+     * Pasar `null` (default) deshabilita la sincronización.
+     */
+    urlParam: _angular_core.InputSignal<string | null>;
+    /**
+     * Emite el array de NeuSelectOption completo (incluyendo data) al cambiar la selección.
+     * Emite [] al limpiar toda la selección.
+     * Los valores del formControl siguen siendo string[].
+     */
+    readonly selectionChange: _angular_core.OutputEmitterRef<NeuSelectOption[]>;
+    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 panelPosition: _angular_core.WritableSignal<{
+        position: string | null;
+        top: string | null;
+        left: string | null;
+        width: string | null;
+        maxHeight: string | null;
+    }>;
+    readonly _visibleChips: Signal<string[]>;
+    readonly hasError: Signal<boolean>;
+    readonly describedBy: Signal<string | null>;
+    readonly filteredOptions: Signal<NeuSelectOption[]>;
+    readonly resultsAnnouncement: Signal<string>;
+    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: 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 / Opens the panel and moves focus to the first item */
+    onTriggerKey(event: Event): void;
+    onTriggerActionKey(event: KeyboardEvent): void;
+    focusTrigger(): void;
+    /** Navega entre opciones con flechas / Navigates between options with arrows */
+    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;
+    onWindowResize(): void;
+    onWindowScroll(): void;
+    private syncPanelPosition;
+    private resetPanelPosition;
+    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; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "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; }; "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; }; "urlParam": { "alias": "urlParam"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, ["itemTpl"], never, true, never>;
+}
+
+export { NeuMultiselectComponent, NeuMultiselectItemDirective };

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

@@ -0,0 +1,69 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Í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`. / Internal Angular route (RouterLink). Excludes `href`. */
+    route?: string;
+    /** URL externa. Se abre en nueva pestaña. Excluye `route`. / External URL. Opens in a new tab. Excludes `route`. */
+    href?: string;
+    /** Ítems hijo (nivel 2). Cada hijo puede tener sus propios `children` (nivel 3). / Child items (level 2). Each child can have its own `children` (level 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 / Navigation item list */
+    items: _angular_core.InputSignal<NeuNavItem[]>;
+    /** Estado inicial colapsado / Initial collapsed state */
+    collapsed: _angular_core.InputSignal<boolean>;
+    /** Muestra el botón de colapsar/expandir / Shows the collapse/expand button */
+    collapsible: _angular_core.InputSignal<boolean>;
+    /** Etiqueta accesible del <nav> / Accessible label for the <nav> */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón cuando el nav está colapsado / Aria-label for the button when the nav is collapsed */
+    expandLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón cuando el nav está expandido / Aria-label for the button when the nav is expanded */
+    collapseLabel: _angular_core.InputSignal<string>;
+    /** Emite cuando cambia el estado colapsado / Emits when the collapsed state changes */
+    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>;
+}
+
+export { NeuNavComponent };
+export type { NeuNavItem };

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

@@ -0,0 +1,60 @@
+import * as i0 from '@angular/core';
+
+type NeuNotificationType = 'info' | 'success' | 'warning' | 'error';
+interface NeuNotification {
+    id: string;
+    type: NeuNotificationType;
+    title?: string;
+    message: string;
+    /** Auto-dismiss duration in ms (0 = persistent) */
+    duration?: number;
+    /** Icon text / emoji */
+    icon?: string;
+    timestamp: Date;
+    read: boolean;
+}
+interface NeuNotificationOptions extends Omit<NeuNotification, 'id' | 'timestamp' | 'read'> {
+}
+/**
+ * NeuralUI NotificationService
+ *
+ * Servicio inyectable que gestiona la cola de notificaciones.
+ *
+ * Uso:
+ *   inject(NeuNotificationService).push({ type: 'success', message: '¡Guardado!' });
+ */
+declare class NeuNotificationService {
+    readonly notifications: i0.WritableSignal<NeuNotification[]>;
+    readonly unreadCount: i0.Signal<number>;
+    /** Agrega una notificación / Adds a notification */
+    push(opts: Partial<NeuNotificationOptions> & Pick<NeuNotificationOptions, 'message'>): string;
+    /** Elimina una notificación / Removes a notification */
+    remove(id: string): void;
+    /** Marca todas como leídas / Marks all as read */
+    markAllRead(): void;
+    /** Elimina todas / Clears all */
+    clearAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NeuNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NeuNotificationService>;
+}
+/**
+ * NeuralUI NotificationCenter Component
+ *
+ * Icono de campana con badge de no leídos y panel de notificaciones
+ * deslizante. Consume NeuNotificationService.
+ *
+ * Uso:
+ *   <neu-notification-center />
+ */
+declare class NeuNotificationCenterComponent {
+    readonly _svc: NeuNotificationService;
+    readonly _isOpen: i0.WritableSignal<boolean>;
+    readonly _panelId: string;
+    _toggle(): void;
+    _relativeTime(date: Date): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NeuNotificationCenterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NeuNotificationCenterComponent, "neu-notification-center", never, {}, {}, never, never, true, never>;
+}
+
+export { NeuNotificationCenterComponent, NeuNotificationService };
+export type { NeuNotification, NeuNotificationOptions, NeuNotificationType };

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

@@ -0,0 +1,63 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * NeuralUI NumberInput Component
+ *
+ * Input numérico con botones de incremento/decremento. Implementa CVA.
+ * Soporta layout apilado (stacked), horizontal y vertical.
+ *
+ * Numeric input with increment/decrement buttons. Implements CVA.
+ * Supports stacked, horizontal and vertical layouts.
+ *
+ * Uso: <neu-number-input [min]="0" [max]="99" label="Cantidad" />
+ */
+declare class NeuNumberInputComponent implements ControlValueAccessor {
+    /** Valor mínimo / Min value */
+    readonly min: _angular_core.InputSignal<number>;
+    /** Valor máximo / Max value */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Incremento / Step */
+    readonly step: _angular_core.InputSignal<number>;
+    /** Etiqueta para el input (accesibilidad) / Label for the input (accessibility) */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Aria-label del botón de decremento */
+    readonly decrementLabel: _angular_core.InputSignal<string>;
+    /** Aria-label del botón de incremento */
+    readonly incrementLabel: _angular_core.InputSignal<string>;
+    /** Muestra los botones en vertical / Shows buttons vertically */
+    readonly vertical: _angular_core.InputSignal<boolean>;
+    /** Agrupa ambos botones apilados al final del input / Groups both buttons stacked at input end */
+    readonly stacked: _angular_core.InputSignal<boolean>;
+    /** Tamaño del campo: 'sm' = 36px | 'md' = 48px | 'lg' = 56px / Field size */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Emitido en cada cambio / Emitted on each change */
+    readonly valueChange: _angular_core.OutputEmitterRef<number>;
+    readonly _id: string;
+    readonly _cvaDisabled: _angular_core.WritableSignal<boolean>;
+    readonly _value: _angular_core.WritableSignal<number>;
+    readonly hostClasses: _angular_core.Signal<{
+        'neu-number-input': boolean;
+        'neu-number-input--vertical': boolean;
+        'neu-number-input--stacked': boolean;
+        'neu-number-input--disabled': boolean;
+        'neu-number-input--sm': boolean;
+        'neu-number-input--lg': boolean;
+    }>;
+    private _onChange;
+    private _onTouched;
+    writeValue(val: number | null): void;
+    registerOnChange(fn: (v: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    increment(): void;
+    decrement(): void;
+    onInputChange(event: Event): void;
+    onBlur(): void;
+    private _emit;
+    private _clamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuNumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuNumberInputComponent, "neu-number-input", never, { "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; }; "decrementLabel": { "alias": "decrementLabel"; "required": false; "isSignal": true; }; "incrementLabel": { "alias": "incrementLabel"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { NeuNumberInputComponent };

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

@@ -0,0 +1,30 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * 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) / Current page (1-indexed) */
+    page: _angular_core.InputSignal<number>;
+    /** Total de ítems / Total items */
+    total: _angular_core.InputSignal<number>;
+    /** Ítems por página / Items per page */
+    pageSize: _angular_core.InputSignal<number>;
+    /** Número máximo de botones de página visibles (sin contar anterior/siguiente) / Maximum number of visible page buttons (not counting prev/next) */
+    maxVisible: _angular_core.InputSignal<number>;
+    /** Emite la nueva página al hacer click / Emits the new page on 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>;
+}
+
+export { NeuPaginationComponent };

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

@@ -0,0 +1,73 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef } from '@angular/core';
+
+type NeuPopoverPosition = 'top' | 'bottom' | 'left' | 'right';
+type NeuPopoverTrigger = 'click' | 'hover' | 'focus';
+/**
+ * NeuralUI Popover Overlay Component (internal)
+ * Renderizado por CDK Portal — no usar directamente.
+ */
+declare class NeuPopoverOverlayComponent {
+    readonly _text: _angular_core.WritableSignal<string>;
+    _templateRef: TemplateRef<unknown> | null;
+    _context: unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuPopoverOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuPopoverOverlayComponent, "neu-popover-overlay", never, {}, {}, never, never, true, never>;
+}
+/**
+ * NeuralUI Popover Directive
+ *
+ * Muestra un popover flotante anclado al elemento host usando CDK Overlay.
+ *
+ * Uso:
+ *   <button [neuPopoverTemplate]="myTpl">Info</button>
+ *   <ng-template #myTpl>Contenido del popover</ng-template>
+ *
+ *   <button [neuPopoverText]="'Descripción detallada'">Hover me</button>
+ */
+declare class NeuPopoverDirective implements OnDestroy {
+    /** Template del contenido / Content template */
+    readonly neuPopover: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Texto plano cuando no hay template / Plain text when no template */
+    readonly neuPopoverText: _angular_core.InputSignal<string>;
+    /** Posición preferida / Preferred position */
+    readonly neuPopoverPosition: _angular_core.InputSignal<NeuPopoverPosition>;
+    /** Trigger del popover / Popover trigger */
+    readonly neuPopoverTrigger: _angular_core.InputSignal<NeuPopoverTrigger>;
+    /** Desactiva el popover / Disables the popover */
+    readonly neuPopoverDisabled: _angular_core.InputSignal<boolean>;
+    /** Contexto del template / Template context */
+    readonly neuPopoverContext: _angular_core.InputSignal<unknown>;
+    /** Emitido al abrir / Emitted on open */
+    readonly popoverOpened: _angular_core.OutputEmitterRef<void>;
+    /** Emitido al cerrar / Emitted on close */
+    readonly popoverClosed: _angular_core.OutputEmitterRef<void>;
+    readonly _isOpen: _angular_core.WritableSignal<boolean>;
+    private readonly _overlay;
+    private readonly _el;
+    private readonly _injector;
+    private readonly _vcr;
+    private _overlayRef;
+    private _compRef;
+    onHostClick(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    /** Abre el popover / Opens the popover */
+    open(): void;
+    /** Cierra el popover / Closes the popover */
+    close(): void;
+    /** Alterna la visibilidad / Toggles visibility */
+    toggle(): void;
+    ngOnDestroy(): void;
+    protected _hostAriaHasPopup(): 'dialog' | null;
+    protected _hostAriaExpanded(): 'true' | 'false' | null;
+    private _toggle;
+    private _createOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuPopoverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuPopoverDirective, "[neuPopover]", ["neuPopover"], { "neuPopover": { "alias": "neuPopover"; "required": false; "isSignal": true; }; "neuPopoverText": { "alias": "neuPopoverText"; "required": false; "isSignal": true; }; "neuPopoverPosition": { "alias": "neuPopoverPosition"; "required": false; "isSignal": true; }; "neuPopoverTrigger": { "alias": "neuPopoverTrigger"; "required": false; "isSignal": true; }; "neuPopoverDisabled": { "alias": "neuPopoverDisabled"; "required": false; "isSignal": true; }; "neuPopoverContext": { "alias": "neuPopoverContext"; "required": false; "isSignal": true; }; }, { "popoverOpened": "popoverOpened"; "popoverClosed": "popoverClosed"; }, never, never, true, never>;
+}
+
+export { NeuPopoverDirective, NeuPopoverOverlayComponent };
+export type { NeuPopoverPosition, NeuPopoverTrigger };