@neural-ui/core 1.2.1 → 1.3.0

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

@@ -0,0 +1,66 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+interface NeuContextMenuItem {
+    /** Key para identificar la acción / Key to identify the action */
+    key: string;
+    /** Texto visible / Visible text */
+    label: string;
+    /** Icono opcional (texto/emoji) / Optional icon (text/emoji) */
+    icon?: string;
+    /** Separador antes de este item / Separator before this item */
+    separator?: boolean;
+    /** Desactiva el item / Disables the item */
+    disabled?: boolean;
+    /** Variante de color / Color variant */
+    variant?: 'default' | 'danger';
+}
+/**
+ * NeuralUI ContextMenu Overlay Component (internal)
+ */
+declare class NeuContextMenuOverlayComponent {
+    readonly _items: _angular_core.WritableSignal<NeuContextMenuItem[]>;
+    _selectFn: ((item: NeuContextMenuItem) => void) | null;
+    _escapeFn: (() => void) | null;
+    select(item: NeuContextMenuItem): void;
+    _onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuContextMenuOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuContextMenuOverlayComponent, "neu-context-menu-overlay", never, {}, {}, never, never, true, never>;
+}
+/**
+ * NeuralUI ContextMenu Directive
+ *
+ * Muestra un menú contextual al hacer clic derecho sobre el elemento host.
+ *
+ * Uso:
+ *   <div [neuContextMenu]="menuItems" (menuItemClick)="onItem($event)">
+ *     Clic derecho aquí
+ *   </div>
+ */
+declare class NeuContextMenuDirective implements OnDestroy {
+    /** Ítems del menú / Menu items */
+    readonly neuContextMenu: _angular_core.InputSignal<NeuContextMenuItem[]>;
+    /** Desactiva el menú / Disables the menu */
+    readonly neuContextMenuDisabled: _angular_core.InputSignal<boolean>;
+    /** Emitido al seleccionar un ítem / Emitted when an item is selected */
+    readonly menuItemClick: _angular_core.OutputEmitterRef<NeuContextMenuItem>;
+    /** Emitido al abrir / Emitted on open */
+    readonly menuOpened: _angular_core.OutputEmitterRef<void>;
+    /** Emitido al cerrar / Emitted on close */
+    readonly menuClosed: _angular_core.OutputEmitterRef<void>;
+    private readonly _overlay;
+    private readonly _el;
+    private readonly _injector;
+    private readonly _vcr;
+    private _overlayRef;
+    private _compRef;
+    onContextMenu(event: MouseEvent): void;
+    private _open;
+    private _close;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuContextMenuDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuContextMenuDirective, "[neuContextMenu]", ["neuContextMenu"], { "neuContextMenu": { "alias": "neuContextMenu"; "required": false; "isSignal": true; }; "neuContextMenuDisabled": { "alias": "neuContextMenuDisabled"; "required": false; "isSignal": true; }; }, { "menuItemClick": "menuItemClick"; "menuOpened": "menuOpened"; "menuClosed": "menuClosed"; }, never, never, true, never>;
+}
+
+export { NeuContextMenuDirective, NeuContextMenuOverlayComponent };
+export type { NeuContextMenuItem };

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

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+interface NeuDashboardTileConfig {
+    /** Identificador único / Unique identifier */
+    id: string;
+    /** Número de columnas que ocupa / Column span */
+    cols?: number;
+    /** Número de filas que ocupa / Row span */
+    rows?: number;
+    /** Título del tile / Tile title */
+    title?: string;
+}
+/**
+ * NeuralUI DashboardGrid
+ *
+ * Cuadrícula de tiles reordenables mediante drag-and-drop (CDK DragDrop).
+ *
+ * Uso:
+ *   <neu-dashboard-grid [tiles]="tileConfigs" [columns]="3">
+ *     <ng-template neuDashboardTile id="tile-1">...</ng-template>
+ *   </neu-dashboard-grid>
+ */
+declare class NeuDashboardGridComponent {
+    private readonly _host;
+    readonly tiles: _angular_core.InputSignal<NeuDashboardTileConfig[]>;
+    readonly columns: _angular_core.InputSignal<number>;
+    /** Emitido cuando el orden cambia / Emitted when order changes */
+    readonly orderChange: _angular_core.OutputEmitterRef<NeuDashboardTileConfig[]>;
+    readonly _orderedTiles: _angular_core.WritableSignal<NeuDashboardTileConfig[]>;
+    readonly _tileSlots: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    constructor();
+    _onDrop(event: CdkDragDrop<NeuDashboardTileConfig[]>): void;
+    private _attachProjectedTiles;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuDashboardGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuDashboardGridComponent, "neu-dashboard-grid", never, { "tiles": { "alias": "tiles"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "orderChange": "orderChange"; }, never, ["*"], true, never>;
+}
+
+export { NeuDashboardGridComponent };
+export type { NeuDashboardTileConfig };

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

@@ -0,0 +1,178 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/** Rango de fechas seleccionado / Selected date range */
+interface NeuDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface CalendarDay {
+    date: Date;
+    inMonth: boolean;
+    isToday: boolean;
+    isSelected: boolean;
+}
+interface DrumSlot {
+    value: number;
+    offset: number;
+    label: string;
+}
+interface RangeCell {
+    date: Date;
+    day: number;
+    ts: number;
+    current: boolean;
+    today: boolean;
+    selected: boolean;
+    rangeStart: boolean;
+    rangeEnd: boolean;
+    inRange: boolean;
+    label: string;
+}
+/**
+ * NeuralUI DateInput — campo de fecha/hora unificado con modo rango.
+ * Unified date/time field with range mode.
+ *
+ * Uso básico / Basic usage:
+ *   <neu-date-input type="date"             [formControl]="dateCtrl" />
+ *   <neu-date-input type="time"             [formControl]="timeCtrl" />
+ *   <neu-date-input type="datetime-local"   [formControl]="dateTimeCtrl" />
+ *   <neu-date-input type="range"            [formControl]="rangeCtrl" />
+ */
+declare class NeuDateInputComponent implements ControlValueAccessor, OnDestroy {
+    #private;
+    private readonly el;
+    private readonly doc;
+    private _langObserver?;
+    /** Tipo del campo / Field type */
+    type: _angular_core.InputSignal<"date" | "time" | "datetime-local" | "range">;
+    /** Etiqueta / Label */
+    label: _angular_core.InputSignal<string>;
+    /** Texto de ayuda / Help text */
+    hint: _angular_core.InputSignal<string>;
+    /** Mensaje de error / Error message */
+    errorMessage: _angular_core.InputSignal<string>;
+    /** Deshabilita / Disabled */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Tamaño del campo: 'sm' = 36px | 'md' = 48px | 'lg' = 56px / Field size */
+    size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Solo lectura / Read only */
+    readonly: _angular_core.InputSignal<boolean>;
+    /** Nombre / Field name */
+    name: _angular_core.InputSignal<string>;
+    /** ID accesible / Accessible ID */
+    inputId: _angular_core.InputSignal<string>;
+    /** Requerido / Required */
+    required: _angular_core.InputSignal<boolean>;
+    /** Mínimo / Minimum */
+    min: _angular_core.InputSignal<string | null>;
+    /** Máximo / Maximum */
+    max: _angular_core.InputSignal<string | null>;
+    /** Paso / Step */
+    step: _angular_core.InputSignal<number | null>;
+    /** Locale explícito opcional / Optional explicit locale */
+    locale: _angular_core.InputSignal<string | null>;
+    /** Placeholder del trigger de rango / Range trigger placeholder */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Formato de fecha en modo rango / Date display format in range mode */
+    dateFormat: _angular_core.InputSignal<"short" | "medium" | "long" | "full" | "numeric">;
+    /** Emitido al confirmar el rango / Emitted when range is confirmed */
+    readonly rangeChange: _angular_core.OutputEmitterRef<NeuDateRange>;
+    protected readonly _id: string;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly _isRange: _angular_core.Signal<boolean>;
+    private readonly _cvaDisabled;
+    readonly isDisabledFinal: _angular_core.Signal<boolean>;
+    readonly hasError: _angular_core.Signal<boolean>;
+    private _onChange;
+    private _onTouched;
+    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>;
+    private readonly _today;
+    private readonly _documentLang;
+    private readonly _pickStart;
+    private readonly _pickEnd;
+    private readonly _hoverDate;
+    readonly _leftCursor: _angular_core.WritableSignal<Date>;
+    readonly _rightCursor: _angular_core.Signal<Date>;
+    readonly _hasRange: _angular_core.Signal<boolean>;
+    readonly _canApply: _angular_core.Signal<boolean>;
+    readonly _resolvedLocale: _angular_core.Signal<string>;
+    readonly _texts: _angular_core.Signal<{
+        rangeAriaLabel: string;
+        prevMonth: string;
+        nextMonth: string;
+        clear: string;
+        apply: string;
+        chooseDate: string;
+        delete: string;
+        today: string;
+        prevHour: string;
+        nextHour: string;
+        prevMinute: string;
+        nextMinute: string;
+        rangePlaceholder: string;
+        timePlaceholder: string;
+        datePlaceholder: string;
+        dateTimePlaceholder: string;
+    }>;
+    readonly _weekDayLabels: _angular_core.Signal<string[]>;
+    readonly _leftTitle: _angular_core.Signal<string>;
+    readonly _rightTitle: _angular_core.Signal<string>;
+    readonly _leftDays: _angular_core.Signal<RangeCell[]>;
+    readonly _rightDays: _angular_core.Signal<RangeCell[]>;
+    readonly _rangePlaceholderText: _angular_core.Signal<string>;
+    constructor();
+    ngOnDestroy(): void;
+    private _monthTitle;
+    readonly _rangeDisplayValue: _angular_core.Signal<string>;
+    private _fmtDate;
+    private _buildRangeMonth;
+    private _rangeCell;
+    _prevLeft(): void;
+    _nextLeft(): void;
+    _prevRight(): void;
+    _nextRight(): void;
+    _selectDay(date: Date): void;
+    _hoverDay(date: Date): void;
+    _applyRange(): void;
+    _clearRange(): void;
+    readonly displayValue: _angular_core.Signal<string>;
+    readonly placeholderText: _angular_core.Signal<string>;
+    readonly monthLabel: _angular_core.Signal<string>;
+    readonly weekdays: _angular_core.Signal<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;
+    writeValue(value: string | NeuDateRange | null): void;
+    registerOnChange(fn: (v: string | NeuDateRange) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    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; }; "size": { "alias": "size"; "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; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; }, { "rangeChange": "rangeChange"; }, never, never, true, never>;
+}
+
+export { NeuDateInputComponent };
+export type { NeuDateRange };

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

@@ -0,0 +1,20 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * 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<"horizontal" | "vertical">;
+    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>;
+}
+
+export { NeuDividerComponent };

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

@@ -0,0 +1,32 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * 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(). / Lucide icon name registered with provideIcons(). */
+    icon: _angular_core.InputSignal<string>;
+    /** Tamaño del icono. Por defecto 3rem. / Icon size. Default 3rem. */
+    iconSize: _angular_core.InputSignal<string>;
+    /** Título principal del estado vacío. / Main title of the empty state. */
+    title: _angular_core.InputSignal<string>;
+    /** Descripción secundaria opcional. / Optional secondary description. */
+    description: _angular_core.InputSignal<string>;
+    /** Texto del botón de acción. Si está vacío, no se muestra el botón. / Action button text. If empty, the button is not shown. */
+    actionLabel: _angular_core.InputSignal<string>;
+    /** Emite cuando el usuario hace clic en el botón de acción. / Emits when the user clicks the action button. */
+    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>;
+}
+
+export { NeuEmptyStateComponent };

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

@@ -0,0 +1,49 @@
+import * as _angular_core from '@angular/core';
+
+interface NeuFilterChip {
+    /** Identificador único del filtro / Unique filter identifier */
+    key: string;
+    /** Etiqueta visible / Visible label */
+    label: string;
+    /** Si el chip está activo / Whether the chip is active */
+    active?: boolean;
+}
+/**
+ * NeuralUI FilterBar Component
+ *
+ * Fila de chips de filtro con selección individual y botón "Limpiar todo".
+ *
+ * Uso:
+ *   <neu-filter-bar [filters]="chips" (filterChange)="onFilter($event)" />
+ */
+declare class NeuFilterBarComponent {
+    /** Lista inicial de filtros / Initial filter chips list */
+    readonly filters: _angular_core.InputSignal<NeuFilterChip[]>;
+    /** Muestra el botón "Limpiar todo" cuando hay activos / Shows "Clear all" when any active */
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    /** Texto del botón de limpiar / Clear button text */
+    readonly clearLabel: _angular_core.InputSignal<string>;
+    /** Permite selección múltiple / Allows multi-selection */
+    readonly multi: _angular_core.InputSignal<boolean>;
+    /** Aria-label de la barra / Aria-label for the bar */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Emitido con los chips activos al cambiar / Emitted with active chips on change */
+    readonly filterChange: _angular_core.OutputEmitterRef<NeuFilterChip[]>;
+    readonly _id: string;
+    readonly _chips: _angular_core.WritableSignal<NeuFilterChip[]>;
+    readonly _hasActive: _angular_core.Signal<boolean>;
+    readonly hostClasses: _angular_core.Signal<{
+        'neu-filter-bar': boolean;
+        'neu-filter-bar--multi': boolean;
+    }>;
+    constructor();
+    toggle(chip: NeuFilterChip): void;
+    clearAll(): void;
+    /** Activa chips por sus keys programáticamente / Activate chips by keys programmatically */
+    setActive(keys: string[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuFilterBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuFilterBarComponent, "neu-filter-bar", never, { "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "filterChange": "filterChange"; }, never, never, true, never>;
+}
+
+export { NeuFilterBarComponent };
+export type { NeuFilterChip };

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

@@ -0,0 +1,33 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * 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() / Icon name registered with 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. / Resolved size: uses the `size` input or falls back to the CSS token. */
+    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>;
+}
+
+export { NeuIconComponent };

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

@@ -0,0 +1,67 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnDestroy } from '@angular/core';
+
+interface NeuImageViewerItem {
+    src: string;
+    alt?: string;
+    caption?: string;
+}
+declare const NEU_IV_DATA: InjectionToken<_NeuIvData>;
+interface _NeuIvData {
+    items: NeuImageViewerItem[];
+    initialIndex: number;
+    close: () => void;
+}
+/**
+ * Componente interno del overlay del visor de imágenes.
+ * No debe usarse directamente — es instanciado por la directiva.
+ */
+declare class NeuImageViewerOverlayComponent {
+    readonly _data: _NeuIvData;
+    readonly _index: _angular_core.WritableSignal<number>;
+    readonly _scale: _angular_core.WritableSignal<number>;
+    readonly _panX: _angular_core.WritableSignal<number>;
+    readonly _panY: _angular_core.WritableSignal<number>;
+    private _dragging;
+    private _dragStart;
+    readonly _current: _angular_core.Signal<NeuImageViewerItem>;
+    readonly _transform: _angular_core.Signal<string>;
+    _navigate(dir: -1 | 1): void;
+    _zoom(delta: number): void;
+    _resetZoom(): void;
+    _onWheel(e: WheelEvent): void;
+    _onMouseDown(e: MouseEvent): void;
+    _onBackdropClick(_e: MouseEvent): void;
+    _onKey(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuImageViewerOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuImageViewerOverlayComponent, "neu-image-viewer-overlay", never, {}, {}, never, never, true, never>;
+}
+/**
+ * NeuralUI ImageViewer Directive
+ *
+ * Adjunta un visor de imágenes en pantalla completa a cualquier elemento.
+ *
+ * Uso básico (imagen única):
+ *   <img src="photo.jpg" [neuImageViewer]="src" />
+ *
+ * Uso con galería:
+ *   <img src="photo.jpg" [neuImageViewer]="items" [neuIvIndex]="0" />
+ */
+declare class NeuImageViewerDirective implements OnDestroy {
+    /** Puede ser una URL, NeuImageViewerItem o un array de items */
+    readonly neuImageViewer: _angular_core.InputSignal<string | NeuImageViewerItem | NeuImageViewerItem[]>;
+    /** Índice inicial cuando se pasa un array */
+    readonly neuIvIndex: _angular_core.InputSignal<number>;
+    private readonly _overlay;
+    private readonly _injector;
+    private _overlayRef;
+    open(): void;
+    close(): void;
+    ngOnDestroy(): void;
+    private _normalizeItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuImageViewerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuImageViewerDirective, "[neuImageViewer]", ["neuImageViewer"], { "neuImageViewer": { "alias": "neuImageViewer"; "required": false; "isSignal": true; }; "neuIvIndex": { "alias": "neuIvIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NEU_IV_DATA, NeuImageViewerDirective, NeuImageViewerOverlayComponent };
+export type { NeuImageViewerItem };

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

@@ -0,0 +1,49 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * NeuralUI InputOTP Component
+ *
+ * N-digit OTP code input split into individual cells. Implements CVA.
+ *
+ * Uso: <neu-input-otp [length]="6" (completed)="onOtp($event)" formControlName="code" />
+ */
+declare class NeuInputOTPComponent implements ControlValueAccessor {
+    /** Número de celdas / Number of cells */
+    readonly length: _angular_core.InputSignal<number>;
+    /** Tipo de caracteres: numeric | alphanumeric / Character type */
+    readonly type: _angular_core.InputSignal<"numeric" | "alphanumeric">;
+    /** Emitido cuando todas las celdas están completas / Emitted when all cells are filled */
+    readonly completed: _angular_core.OutputEmitterRef<string>;
+    /** Emitido en cada cambio parcial / Emitted on each partial change */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    readonly _id: string;
+    readonly _cvaDisabled: _angular_core.WritableSignal<boolean>;
+    readonly _digits: _angular_core.WritableSignal<string[]>;
+    readonly _cells: _angular_core.Signal<unknown[]>;
+    /** Array de dígitos con padding de vacíos — nunca undefined / Digits array padded with empty strings — never undefined */
+    readonly _paddedDigits: _angular_core.Signal<string[]>;
+    readonly hostClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        'neu-input-otp': boolean;
+        'neu-input-otp--disabled': boolean;
+    }>;
+    private readonly _cellEls;
+    private _onChange;
+    private _onTouched;
+    writeValue(val: string | null): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    onCellInput(event: Event, index: number): void;
+    onKeyDown(event: KeyboardEvent, index: number): void;
+    onPaste(event: ClipboardEvent): void;
+    onFocus(index: number): void;
+    clear(): void;
+    private _sanitize;
+    private _focusCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuInputOTPComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuInputOTPComponent, "neu-input-otp", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "completed": "completed"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { NeuInputOTPComponent };

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

@@ -0,0 +1,86 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+type NeuInputType = 'text' | 'email' | 'password' | 'tel' | 'url' | 'search';
+/**
+ * NeuralUI Input Component
+ *
+ * Input con floating label, iconos y soporte completo para Angular Forms.
+ * Compatible con Reactive Forms mediante FormControl y formularios reactivos.
+ *
+ * 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 / HTML input type */
+    type: _angular_core.InputSignal<NeuInputType>;
+    /** Texto del floating label / Floating label text */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder visible cuando floatingLabel=false / Visible placeholder when floatingLabel=false */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Muestra el label como flotante (true) o estático encima del campo (false) / Shows the label as floating (true) or static above the field (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">;
+    /** Hint de ayuda (visible cuando no hay error) / Help hint (visible when there is no error) */
+    hint: _angular_core.InputSignal<string>;
+    /** Mensaje de error (activa el estado de error) / Error message (activates the error state) */
+    errorMessage: _angular_core.InputSignal<string>;
+    /** Deshabilita el campo / Disables the field */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Atributo autocomplete HTML / HTML autocomplete attribute */
+    autocomplete: _angular_core.InputSignal<string>;
+    /** Muestra zona para icono al inicio / Shows icon slot at the start */
+    startIcon: _angular_core.InputSignal<boolean>;
+    /** Muestra zona para icono al final / Shows icon slot at the end */
+    endIcon: _angular_core.InputSignal<boolean>;
+    /** Nombre del icono lucide a renderizar dentro del campo / Lucide icon name to render inside the field */
+    icon: _angular_core.InputSignal<string>;
+    /** Posición del icono cuando se usa `icon` / Icon position when using `icon` */
+    iconPosition: _angular_core.InputSignal<"left" | "right">;
+    /** ID accesible para el input — generado con contador estable (seguro en SSR) / Accessible ID for the input — generated with stable counter (SSR-safe) */
+    inputId: _angular_core.InputSignal<string>;
+    /** Nombre del campo para formularios nativos / Field name for native forms */
+    name: _angular_core.InputSignal<string>;
+    /** Marca el campo como requerido / Marks the field as required */
+    required: _angular_core.InputSignal<boolean>;
+    /** Hace el campo de solo lectura / Makes the field read-only */
+    readonly: _angular_core.InputSignal<boolean>;
+    /** Longitud máxima de caracteres / Maximum character length */
+    maxlength: _angular_core.InputSignal<number | null>;
+    /** Longitud mínima de caracteres / Minimum character length */
+    minlength: _angular_core.InputSignal<number | null>;
+    /** Valor mínimo (para type=number/date) / Minimum value (for type=number/date) */
+    min: _angular_core.InputSignal<string | null>;
+    /** Valor máximo (para type=number/date) / Maximum value (for type=number/date) */
+    max: _angular_core.InputSignal<string | null>;
+    /** Patrón de validación HTML5 / HTML5 validation pattern */
+    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; }; "size": { "alias": "size"; "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>;
+}
+
+export { NeuInputComponent };
+export type { NeuInputType };