@neural-ui/core 1.2.0 → 1.3.0

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

@@ -0,0 +1,38 @@
+import * as _angular_core from '@angular/core';
+
+interface NeuBreadcrumbItem {
+    /** Etiqueta visible / Visible label */
+    label: string;
+    /** Ruta interna (RouterLink) / Internal route (RouterLink) */
+    route?: string | string[];
+    /** URL externa / External URL */
+    url?: string;
+    /** Icono Lucide opcional / Optional Lucide icon */
+    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 / Navigation item list */
+    items: _angular_core.InputSignal<NeuBreadcrumbItem[]>;
+    /** Separador personalizable / Customizable separator */
+    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>;
+}
+
+export { NeuBreadcrumbComponent };
+export type { NeuBreadcrumbItem };

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

@@ -0,0 +1,55 @@
+import * as _angular_core from '@angular/core';
+
+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 / Visual button variant */
+    variant: _angular_core.InputSignal<NeuButtonVariant>;
+    /** Tamaño del botón / Button size */
+    size: _angular_core.InputSignal<NeuButtonSize>;
+    /** Deshabilita el botón y bloquea la interacción / Disables the button and blocks interaction */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Muestra un spinner y deshabilita mientras se procesa / Shows a spinner and disables while processing */
+    loading: _angular_core.InputSignal<boolean>;
+    /** Ocupa el 100% del ancho de su contenedor / Takes up 100% of its container width */
+    fullWidth: _angular_core.InputSignal<boolean>;
+    /** Nombre del icono Lucide (ej: 'lucideSave', 'lucidePlus') / Lucide icon name (e.g. '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 / Icon-only mode: applies square padding and hides ng-content */
+    iconOnly: _angular_core.InputSignal<boolean>;
+    /** Etiqueta accesible obligatoria cuando se usa iconOnly (WCAG 4.1.2) / Required accessible label when using iconOnly (WCAG 4.1.2) */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /** Emite el evento de click cuando el botón está activo / Emits the click event when the button is active */
+    neuClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** @internal — reenvía el click nativo al output Angular / forwards the native click to the Angular output */
+    _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>;
+}
+
+export { NeuButtonComponent };
+export type { NeuButtonIconPosition, NeuButtonSize, NeuButtonVariant };

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

@@ -0,0 +1,37 @@
+import * as _angular_core from '@angular/core';
+
+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 / Inner body padding */
+    padding: _angular_core.InputSignal<NeuCardPadding>;
+    /** Efecto hover con elevación de sombra / Hover effect with shadow elevation */
+    hoverable: _angular_core.InputSignal<boolean>;
+    /** Borde con acento de color primario / Border with primary color accent */
+    bordered: _angular_core.InputSignal<boolean>;
+    /** Card compacta sin bordes ni sombras / Compact card without borders or shadows */
+    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>;
+}
+
+export { NeuCardComponent };
+export type { NeuCardPadding };

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

@@ -0,0 +1,236 @@
+import * as _angular_core from '@angular/core';
+
+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. / Chart type. */
+    type: _angular_core.InputSignal<NeuChartType>;
+    /** Series para gráficas de ejes (line, area, bar, pareto…). / Series for axis-based charts (line, area, bar, pareto…). */
+    series: _angular_core.InputSignal<NeuChartSeries[]>;
+    /** Series para gráficas sin ejes (donut, pie). / Series for non-axis charts (donut, pie). */
+    pieSeries: _angular_core.InputSignal<number[]>;
+    /** Etiquetas del eje X. / X-axis labels. */
+    categories: _angular_core.InputSignal<string[]>;
+    /** Etiquetas para donut/pie. / Labels for donut/pie. */
+    labels: _angular_core.InputSignal<string[]>;
+    /** Altura en px. / Height in px. */
+    height: _angular_core.InputSignal<number>;
+    /** Colores custom. Si no se proveen, usa la paleta Neural-Blue. / Custom colors. If not provided, uses the Neural-Blue palette. */
+    colors: _angular_core.InputSignal<string[]>;
+    /** Muestra/oculta las etiquetas de datos. / Shows/hides data labels. */
+    showDataLabels: _angular_core.InputSignal<boolean>;
+    /** Título de la gráfica. / Chart title. */
+    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: number[];
+        curve: any;
+        lineCap: "round";
+    } | {
+        show: boolean;
+        width?: undefined;
+        curve?: undefined;
+        lineCap?: undefined;
+    } | {
+        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;
+            };
+        };
+        radialBar?: undefined;
+        bar?: undefined;
+    } | {
+        radialBar: {
+            hollow: {
+                margin: number;
+                size: string;
+            };
+            track: {
+                background: string;
+                strokeWidth: string;
+                margin: number;
+            };
+            dataLabels: {
+                name: {
+                    fontSize: string;
+                    fontFamily: string;
+                    color: string;
+                    offsetY: number;
+                };
+                value: {
+                    fontSize: string;
+                    fontFamily: string;
+                    fontWeight: number;
+                    color: string;
+                    offsetY: number;
+                    formatter: (v: number) => string;
+                };
+                total: {
+                    show: boolean;
+                    label: string;
+                    fontSize: string;
+                    fontFamily: string;
+                    color: string;
+                    formatter: (w: any) => string;
+                };
+            };
+        };
+        pie?: undefined;
+        bar?: undefined;
+    } | {
+        bar: {
+            horizontal: boolean;
+            borderRadius: number;
+            columnWidth: string;
+            barHeight: string;
+            dataLabels: {
+                total: {
+                    enabled: boolean;
+                };
+            };
+        };
+        pie?: undefined;
+        radialBar?: undefined;
+    } | {
+        pie?: undefined;
+        radialBar?: 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>;
+}
+
+export { NeuChartComponent };
+export type { NeuChartSeries, NeuChartType };

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

@@ -0,0 +1,33 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * 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 / Internal disabled state — combines the `disabled` input with 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>;
+}
+
+export { NeuCheckboxComponent };

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

@@ -0,0 +1,53 @@
+import * as _angular_core from '@angular/core';
+
+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 / Color variant */
+    variant: _angular_core.InputSignal<NeuChipVariant>;
+    /** Tamaño / Size */
+    size: _angular_core.InputSignal<NeuChipSize>;
+    /** Estado seleccionado / Selected state */
+    selected: _angular_core.InputSignal<boolean>;
+    /** Muestra botón de cierre / Shows close button */
+    removable: _angular_core.InputSignal<boolean>;
+    /** Deshabilitado / Disabled */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Aria-label del botón de eliminar / Aria-label for the delete button */
+    removeAriaLabel: _angular_core.InputSignal<string>;
+    /** Emite al hacer clic o pulsar espacio/enter / Emits on click or space/enter press */
+    selectedChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Emite al pulsar el botón de cierre / Emits when the close button is pressed */
+    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;
+    }>;
+    /** Rol ARIA del host: 'button' cuando seleccionable, 'group' cuando también eliminable / Host ARIA role: 'button' when selectable, 'group' when removable */
+    readonly _hostRole: _angular_core.Signal<"group" | "button">;
+    /** aria-pressed solo cuando actúa como botón toggle / aria-pressed only when acting as toggle button */
+    readonly _hostAriaPressed: _angular_core.Signal<boolean | null>;
+    /** tabindex nulo en el host grupo para no saturar el orden de foco / null tabindex on group host to not saturate focus order */
+    readonly _hostTabindex: _angular_core.Signal<number | null>;
+    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>;
+}
+
+export { NeuChipComponent };
+export type { NeuChipSize, NeuChipVariant };

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

@@ -0,0 +1,55 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * 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;
+    private readonly destroyRef;
+    /** Código fuente a mostrar / Source code to display */
+    code: _angular_core.InputSignal<string>;
+    /** Nombre del lenguaje (decorativo) / Language name (decorative) */
+    lang: _angular_core.InputSignal<string>;
+    /**
+     * Identificador de lenguaje estándar (typescript, scss, html, bash…).
+     * Genera automáticamente el label legible para el badge.
+     * Language identifier — auto-generates a readable badge label.
+     */
+    language: _angular_core.InputSignal<string>;
+    /** Label legible derivado de lang o language / Readable label derived from lang or language */
+    protected readonly displayLang: _angular_core.Signal<string>;
+    /** Texto del botón cuando no se ha copiado / Button text when not yet copied */
+    copyLabel: _angular_core.InputSignal<string | undefined>;
+    /** Texto del botón tras copiar / Button text after copying */
+    copiedLabel: _angular_core.InputSignal<string | undefined>;
+    /** Aria-label del botón copiar / Aria-label for the copy button */
+    copyAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Aria-label del botón tras copiar / Aria-label for the button after copying */
+    copiedAriaLabel: _angular_core.InputSignal<string | undefined>;
+    private readonly localeLabels;
+    protected readonly resolvedCopyLabel: _angular_core.Signal<string>;
+    protected readonly resolvedCopiedLabel: _angular_core.Signal<string>;
+    protected readonly resolvedCopyAriaLabel: _angular_core.Signal<string>;
+    protected readonly resolvedCopiedAriaLabel: _angular_core.Signal<string>;
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
+    private _copyTimer?;
+    constructor();
+    copy(): void;
+    private _markCopied;
+    private _getLocaleLabels;
+    private _resolveInputLabel;
+    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; }; "language": { "alias": "language"; "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>;
+}
+
+export { NeuCodeBlockComponent };

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

@@ -0,0 +1,55 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+type NeuColorMode = 'hex' | 'rgb' | 'hsl';
+/**
+ * NeuralUI ColorPicker
+ *
+ * Selector de color con swatch, hue slider y modos hex/rgb/hsl. CVA.
+ *
+ * Uso:
+ *   <neu-color-picker [formControl]="colorCtrl" mode="hex" />
+ */
+declare class NeuColorPickerComponent implements ControlValueAccessor {
+    readonly mode: _angular_core.InputSignal<NeuColorMode>;
+    /** Emitido al cambiar el color / Emitted when color changes */
+    readonly colorChange: _angular_core.OutputEmitterRef<string>;
+    readonly _id: string;
+    readonly _modes: NeuColorMode[];
+    readonly _swatches: string[];
+    readonly _isOpen: _angular_core.WritableSignal<boolean>;
+    readonly _cvaDisabled: _angular_core.WritableSignal<boolean>;
+    readonly _hue: _angular_core.WritableSignal<number>;
+    readonly _sv: _angular_core.WritableSignal<{
+        s: number;
+        v: number;
+    }>;
+    readonly _activeMode: _angular_core.WritableSignal<NeuColorMode>;
+    private _dragging;
+    private _onChange;
+    private _onTouched;
+    private readonly _el;
+    constructor();
+    _outsideClick(e: MouseEvent): void;
+    readonly _hexValue: _angular_core.Signal<string>;
+    readonly _textValue: _angular_core.Signal<string>;
+    _canvasDown(e: PointerEvent): void;
+    _canvasDrag(e: PointerEvent): void;
+    _canvasUp(e: PointerEvent): void;
+    private _updateFromCanvas;
+    _toggle(): void;
+    _onHueChange(v: number): void;
+    _pickSwatch(hex: string): void;
+    _onTextChange(text: string): void;
+    private _applyHex;
+    private _emit;
+    writeValue(val: string | null): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(d: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuColorPickerComponent, "neu-color-picker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "colorChange": "colorChange"; }, never, never, true, never>;
+}
+
+export { NeuColorPickerComponent };
+export type { NeuColorMode };

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

@@ -0,0 +1,56 @@
+import * as _angular_core from '@angular/core';
+
+interface NeuCommand {
+    id: string;
+    label: string;
+    /** Grupo / Category */
+    group?: string;
+    /** Icono (emoji / texto) / Icon */
+    icon?: string;
+    /** Shortcut display (e.g. '⌘K') */
+    shortcut?: string;
+    /** Handler invocado al seleccionar / Handler called on select */
+    action: () => void;
+}
+/**
+ * NeuralUI CommandPaletteService
+ *
+ * Gestiona los comandos registrados y la apertura/cierre del pallete.
+ *
+ * Uso:
+ *   inject(NeuCommandPaletteService).register({ id: 'goto-home', label: 'Ir al inicio', action: () => router.navigate(['/']) });
+ *   inject(NeuCommandPaletteService).open();
+ */
+declare class NeuCommandPaletteService {
+    private readonly _commands;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly query: _angular_core.WritableSignal<string>;
+    readonly filteredCommands: _angular_core.Signal<NeuCommand[]>;
+    register(...commands: NeuCommand[]): void;
+    unregister(...ids: string[]): void;
+    open(): void;
+    close(): void;
+    execute(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuCommandPaletteService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NeuCommandPaletteService>;
+}
+/**
+ * NeuralUI CommandPalette Component
+ *
+ * Paleta de comandos activada con Cmd+K / Ctrl+K.
+ * Registra el atajos globalmente mientras el componente está montado.
+ *
+ * Uso:
+ *   <neu-command-palette />  <!-- colócalo una vez en el root layout -->
+ */
+declare class NeuCommandPaletteComponent {
+    readonly _svc: NeuCommandPaletteService;
+    readonly _activeIndex: _angular_core.WritableSignal<number>;
+    _onDocKey(e: KeyboardEvent): void;
+    _onInputKey(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuCommandPaletteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuCommandPaletteComponent, "neu-command-palette", never, {}, {}, never, never, true, never>;
+}
+
+export { NeuCommandPaletteComponent, NeuCommandPaletteService };
+export type { NeuCommand };