@litigiovirtual/ius-design-components 1.0.300 → 2.0.0

package/types/litigiovirtual-ius-design-components.d.ts

@@ -0,0 +1,2971 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, EventEmitter, AfterViewInit, OnChanges, SimpleChanges, OnInit, TemplateRef, Signal } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { SafeHtml } from '@angular/platform-browser';
+
+/** Jerarquía visual. `danger` = destructivo (color semántico, no accent). */
+type IusButtonVariant = 'primary' | 'outline' | 'secondary' | 'tertiary' | 'danger';
+/** Tamaño del botón — small ≈31 · medium ≈39 (default) · large ≈45px. */
+type IusButtonSize = 'small' | 'medium' | 'large';
+/** Resultado visual forzado (modo no-dynamic). */
+type IusButtonStatus = 'success' | 'error';
+/** `type` nativo del `<button>`. */
+type IusButtonType = 'button' | 'submit' | 'reset';
+/** Lo que puede devolver `action` en modo `dynamic` (void → success). */
+type IusButtonActionResult = IusButtonStatus | void;
+interface SizePreset$2 {
+    px: string;
+    py: string;
+    fs: string;
+    lh: string;
+    icon: string;
+    gap: string;
+}
+/**
+ * Button — Ius Design v2.
+ *
+ * Botón estándar de Litigiovirtual: 5 jerarquías (`primary` · `outline` ·
+ * `secondary` · `tertiary` · `danger`), 3 tamaños y un modo `dynamic` con la
+ * máquina de estados *Loading → Success/Error* (§6 de Button.ng-spec.md).
+ * Renderiza un `<button>` nativo; para navegación pura usar un enlace/Link.
+ *
+ * Modo `dynamic`: al pulsar ejecuta `action(event)`, muestra `loading` (la
+ * promesa + 400 ms mínimos), luego `success`/`error` durante 800 ms y vuelve a
+ * idle. Una excepción de `action` cae a `error`; resolver sin valor es
+ * `success`. `dynamic` ignora los inputs manuales `loading`/`status`.
+ *
+ * Nota: el `state` de la spec ("solo demos") se omite de la API pública —
+ * mismo criterio que TextField. El playground congela hover/pressed con el
+ * atributo `data-force` en el host (solo CSS); loading/success/error/disabled
+ * se fuerzan con los inputs públicos `loading`/`status`/`disabled`.
+ */
+declare class ButtonComponent implements OnDestroy {
+    /** Jerarquía visual del botón. */
+    variant: IusButtonVariant;
+    /** Texto del botón. Tiene prioridad sobre el contenido proyectado. */
+    label?: string;
+    /** Ligadura Material Symbols Rounded a la izquierda (ej. `"add"`). */
+    prefixIcon?: string;
+    /** Ligadura a la derecha. (Nombre heredado del original — conservar `sufixIcon` para paridad de API.) */
+    sufixIcon?: string;
+    /** Activa la máquina de estado transitorio. Ignora `loading` y `status`. */
+    dynamic: boolean;
+    /** Loading manual. Ignorado si `dynamic`. */
+    loading: boolean;
+    /** Resultado manual. Ignorado si `dynamic`. */
+    status?: IusButtonStatus;
+    /** Deshabilitado. El efectivo también cubre loading/status (§7). */
+    disabled: boolean;
+    /** Fuerza visualmente pressed (demos). */
+    pressed: boolean;
+    /** Ocupa el 100 % del ancho del contenedor (formularios, login). */
+    fullWidth: boolean;
+    /** `type` del `<button>` nativo. */
+    type: IusButtonType;
+    /**
+     * Nombre accesible del `<button>` (equivalente Angular del passthrough
+     * `...rest`/`aria-label` del golden; lo usa OAuthButton al componer).
+     */
+    ariaLabel?: string;
+    /** Acción del modo `dynamic`; su resolución decide success/error (§3). */
+    action?: (event: MouseEvent) => Promise<IusButtonActionResult> | IusButtonActionResult;
+    /**
+     * Tamaño explícito → emite `data-size` y aplica el preset §5. Sin él, el
+     * botón hereda `--ius-control-size` del contenedor (medium por defecto),
+     * igual que el golden con `size="auto"` (regla transversal 9).
+     */
+    size?: IusButtonSize;
+    /** Emite al pulsar. (No `click`: colisiona con el evento nativo del host.) */
+    readonly clicked: EventEmitter<MouseEvent>;
+    /** Preset inline del tamaño explícito (null = heredar vía CSS). */
+    protected get preset(): SizePreset$2 | null;
+    /** Fase de la máquina `dynamic` (§6). */
+    private readonly dynPhase;
+    private timer;
+    private destroyed;
+    protected get phase(): 'idle' | 'loading' | 'success' | 'error';
+    protected get isLoading(): boolean;
+    protected get statusValue(): IusButtonStatus | null;
+    /** Disabled efectivo (§7): `disabled || loading || status`. */
+    protected get isDisabled(): boolean;
+    ngOnDestroy(): void;
+    protected handleClick(event: MouseEvent): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "ius-button", never, { "variant": { "alias": "variant"; "required": false; }; "label": { "alias": "label"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "sufixIcon": { "alias": "sufixIcon"; "required": false; }; "dynamic": { "alias": "dynamic"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "status": { "alias": "status"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "pressed": { "alias": "pressed"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "type": { "alias": "type"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "action": { "alias": "action"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_dynamic: unknown;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_pressed: unknown;
+    static ngAcceptInputType_fullWidth: unknown;
+}
+
+type OrbPose = {
+    yaw: number;
+    pitch: number;
+};
+type OrbMood = 'idle' | 'thinking' | 'speaking' | 'alert' | 'off';
+/** Período del ciclo (segundos) por mood. */
+declare const ORB_PERIODS: Record<string, number>;
+/**
+ * Proyecta el cubo con la pose dada y devuelve el markup SVG interno
+ * (contorno redondeado + aristas internas con fade). El consumidor lo
+ * escribe en el `<g class="cube-g">` (innerHTML, sin re-crear nodos).
+ */
+declare function renderCubeSvg(yaw: number, pitch: number): string;
+declare function poseThinking(p: number): OrbPose;
+/** Balanceo isométrico calmado (idle/alert), amplitud 0.8. */
+declare function poseIso(p: number, amp?: number): OrbPose;
+declare function poseSpeaking(p: number, voice: number): OrbPose;
+/** Envolvente de voz: senos incomensurables → cadencia irregular tipo sílabas (0..1). */
+declare function voiceEnv(t: number): number;
+/** Pose por mood (speaking va aparte porque necesita `voice`). */
+declare function pose(p: number, mood: OrbMood): OrbPose;
+
+/** Ánimo de la presencia de ElenIA. */
+type IusEleniaOrbMood = OrbMood;
+/** Superficie donde vive el orbe; `dark` aviva el flujo sobre navy. */
+type IusEleniaOrbSurface = 'light' | 'dark';
+/**
+ * ElenIAOrb — Ius Design v2.
+ *
+ * Presencia **de marca** de ElenIA (asistente IA): esfera de luz líquida con
+ * el cubo Litigiovirtual proyectado como wireframe que voltea 360°. Es una
+ * marca de presencia, no un control ni un cargador (esperas → Loading/
+ * LoadingMark; persona → Avatar). No expone hover/pressed: la superficie
+ * interactiva la compone el contenedor (`ius-elenia-bubble`).
+ *
+ * El cubo se recalcula por frame con el módulo puro `ius-orb-geometry`
+ * (silueta por convex hull + backface culling + poses por mood); el RAF corre
+ * **fuera de la zona** de Angular para no disparar change detection por
+ * frame. En `paused`, `prefers-reduced-motion` o `mood='off'` no corre RAF:
+ * se dibuja un único frame de reposo.
+ */
+declare class EleniaOrbComponent implements AfterViewInit, OnChanges, OnDestroy {
+    /** Lado del orbe en px (mínimo recomendado 48). Alimenta `--_orb`. */
+    size: number;
+    /** Ánimo de la presencia (§4/§6 de la ng-spec). */
+    mood: IusEleniaOrbMood;
+    /** `dark` aplica `brightness(1.12)` al flujo (más luminoso sobre navy). */
+    surface: IusEleniaOrbSurface;
+    /** Congela la animación en un frame de reposo (también reduced-motion). */
+    paused: boolean;
+    /** Etiqueta accesible del glifo. */
+    ariaLabel: string;
+    private cubeGroup;
+    private readonly zone;
+    private readonly host;
+    private raf;
+    private viewReady;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Cancela el RAF anterior y re-arma según mood/paused (golden useEffect). */
+    private restart;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EleniaOrbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EleniaOrbComponent, "ius-elenia-orb", never, { "size": { "alias": "size"; "required": false; }; "mood": { "alias": "mood"; "required": false; }; "surface": { "alias": "surface"; "required": false; }; "paused": { "alias": "paused"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_size: unknown;
+    static ngAcceptInputType_paused: unknown;
+}
+
+/** Tamaño estructural del FAB (lado del botón / orbe interior). */
+type IusEleniaBubbleSize = 'small' | 'medium' | 'large';
+/** Anclaje flotante; `static` lo deja en el flujo para que ancle el consumidor. */
+type IusEleniaBubblePosition = 'bottom-end' | 'bottom-start' | 'top-end' | 'top-start' | 'static';
+interface SizePreset$1 {
+    box: number;
+    orb: number;
+}
+/**
+ * ElenIABubble — Ius Design v2. Lanzador flotante (FAB) del asistente ElenIA.
+ *
+ * **El orbe ES el botón** (regla rectora de la ng-spec): compone
+ * `ius-elenia-orb` intacto, sin caja/fondo/sombra de chrome en icon-only y
+ * sin recortar su halo. Los estados hover/pressed/open se expresan con la
+ * propia luz del orbe (crece ~1.09 y sube sus vars de luz; pressed comprime
+ * ~.94) — nunca un velo gris. Con `label` se vuelve **extendido**: píldora
+ * navy elevada con el orbe a ras del borde (`surface="dark"`).
+ *
+ * Sin máquina dinámica: es un disparador; `mood`/`open` los controla el
+ * consumidor. `alert` = novedad sin leer (el orbe late como faro — única
+ * señal, sin badge); con `peek` además asoma un mensaje que invita
+ * (solo en `alert`, cerrado e icon-only).
+ */
+declare class EleniaBubbleComponent {
+    /** Ánimo — se pasa tal cual al orbe. `off` además apaga el encendido de hover. */
+    mood: IusEleniaOrbMood;
+    /** Preset estructural §5 (box/orb 48·42 / 60·52 / 72·62). */
+    size: IusEleniaBubbleSize;
+    /** Panel de ElenIA abierto → activo sostenido (refleja `aria-expanded`). */
+    open: boolean;
+    /** Si se pasa, el FAB se vuelve extendido (píldora navy + texto). */
+    label?: string;
+    /** Anclaje flotante (4 esquinas fixed + `static`). */
+    position: IusEleniaBubblePosition;
+    /** Congela la animación del orbe (preview/captura). */
+    paused: boolean;
+    /** Mensaje "peek" que asoma junto al FAB (solo con `mood="alert"`, cerrado e icon-only). */
+    peek?: string;
+    /** Título del peek. */
+    peekTitle: string;
+    /** Ligadura del ícono del peek. */
+    peekIcon: string;
+    /** Nombre accesible; fallback: `label` o "Abrir ElenIA". */
+    ariaLabel?: string;
+    /** Emite al pulsar el FAB (abrir/cerrar el panel). No `click`. */
+    readonly clicked: EventEmitter<MouseEvent>;
+    /** Pulso sobre el cuerpo del peek (abrir directo la novedad). */
+    readonly peekClicked: EventEmitter<MouseEvent>;
+    /** Descarta el peek (la X). */
+    readonly peekDismissed: EventEmitter<MouseEvent>;
+    protected get preset(): SizePreset$1;
+    /** Extendido = hay label (espejo del golden: `label != null && label !== ''`). */
+    protected get extended(): boolean;
+    protected get accessibleLabel(): string;
+    protected get showPeek(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EleniaBubbleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EleniaBubbleComponent, "ius-elenia-bubble", never, { "mood": { "alias": "mood"; "required": false; }; "size": { "alias": "size"; "required": false; }; "open": { "alias": "open"; "required": false; }; "label": { "alias": "label"; "required": false; }; "position": { "alias": "position"; "required": false; }; "paused": { "alias": "paused"; "required": false; }; "peek": { "alias": "peek"; "required": false; }; "peekTitle": { "alias": "peekTitle"; "required": false; }; "peekIcon": { "alias": "peekIcon"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "clicked": "clicked"; "peekClicked": "peekClicked"; "peekDismissed": "peekDismissed"; }, never, never, true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_paused: unknown;
+}
+
+/** Proveedor de identidad soportado. Ampliar = agregar logo + label al mapa. */
+type IusOAuthProvider = 'google' | 'microsoft' | 'linkedin';
+/** Tamaño heredado del Button — small ≈34 · medium ≈40 (default) · large ≈48px; logo 18/20/22. */
+type IusOAuthButtonSize = 'small' | 'medium' | 'large';
+/** `type` nativo del `<button>`. */
+type IusOAuthButtonType = 'button' | 'submit' | 'reset';
+/**
+ * OAuthButton — Ius Design v2.
+ *
+ * Botón de **login con proveedor externo** (Google · Microsoft · LinkedIn).
+ * **Compone `ius-button` (`variant="secondary"`)** e inyecta el logo de marca
+ * + etiqueta como contenido: hereda geometría, tamaños, foco y estados, con
+ * hover/pressed **suavizados** (neutral-4/neutral-5, texto oscuro, sin
+ * inversión — ng-spec §4). NO es un `Button` con `prefixIcon`: el logo es un
+ * asset de marca **SVG inline multicolor** (excepción documentada — no se
+ * tokeniza ni recolorea; `disabled` lo atenúa con `grayscale`).
+ */
+declare class OauthButtonComponent {
+    /** Define el logo de marca y la etiqueta por defecto. */
+    provider: IusOAuthProvider;
+    /** Override del texto (default: nombre del proveedor). */
+    label?: string;
+    /** Tamaño (pasa al Button compuesto; el logo escala 18/20/22). */
+    size: IusOAuthButtonSize;
+    /** Ancho completo — patrón de login apilado. */
+    fullWidth: boolean;
+    /** Deshabilitado: hereda del Button + logo en gris. */
+    disabled: boolean;
+    /** `type` del `<button>` nativo. */
+    type: IusOAuthButtonType;
+    /** Nombre accesible; default `"Continuar con <label>"`. */
+    ariaLabel?: string;
+    /** Emite al pulsar; inicia el flujo del proveedor. (No `click`.) */
+    readonly clicked: EventEmitter<MouseEvent>;
+    protected get text(): string;
+    protected get effectiveAriaLabel(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OauthButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OauthButtonComponent, "ius-oauth-button", never, { "provider": { "alias": "provider"; "required": true; }; "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+    static ngAcceptInputType_fullWidth: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Lado + alineación, más los aliases del Figma y `auto`. */
+type IusPopoverPlacement = 'auto' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end' | 'TL' | 'Top' | 'TR' | 'RT' | 'Right' | 'RB' | 'BL' | 'Bottom' | 'BR' | 'LT' | 'Left' | 'LB';
+/** Cómo abre el popover; `manual` = control externo vía `open`. */
+type IusPopoverTrigger = 'hover' | 'click' | 'focus' | 'manual';
+/** Densidad del padding interno del panel. */
+type IusPopoverPadding = 'default' | 'compact' | 'none';
+type Side = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Popover — Ius Design v2. **MOTOR de anclaje de overlays.**
+ *
+ * Burbuja flotante (título + contenido) anclada a un trigger, con flip
+ * automático al borde del viewport. Es la base que reusan Tooltip, Dropdown,
+ * DateFilter, AppLauncher, etc. Posicionamiento y portal delegados en
+ * **CDK Overlay** (`FlexibleConnectedPositionStrategy`), como exige la
+ * ng-spec — aquí solo se mapean placements/aliases, `auto`, offset y flecha.
+ *
+ * - Trigger `hover` (incluye focus, como el golden) · `click` · `focus` ·
+ *   `manual` (controlado por `open`).
+ * - `anchorRect`: anclaje virtual contra un rect (p. ej. el caret del
+ *   RichTextEditor) en vez del trigger; se reevalúa en scroll/resize.
+ * - `dismissable` (opt-in): cierra por Esc y pointerdown fuera, emitiendo
+ *   `openChange(false)`.
+ * - Contenido: inputs `title`/`content` (strings) o proyección rica con
+ *   `<ng-template iusPopoverContent>`-style: `<div iusPopoverContent>…</div>`.
+ */
+declare class PopoverComponent implements OnInit, OnChanges, OnDestroy {
+    /** Título en negrita arriba (blanco con título = Popover; sin título oscuro = Tooltip). */
+    title?: string;
+    /** Contenido de texto simple. Para contenido rico proyectar `[iusPopoverContent]`. */
+    content?: string;
+    /** 12 colocaciones + aliases del Figma + `auto` (lado con más espacio). */
+    placement: IusPopoverPlacement;
+    /** Cómo abre. `manual` no instala handlers: controlar con `open`. */
+    trigger: IusPopoverTrigger;
+    /** Distancia trigger↔panel en px. */
+    offset: number;
+    /** Modo controlado (undefined = no controlado con `defaultOpen`). */
+    open?: boolean;
+    /** Estado inicial del modo no controlado. */
+    defaultOpen: boolean;
+    /** Rabito del globo. */
+    showArrow: boolean;
+    /** Nunca abre. */
+    disabled: boolean;
+    /** Anclaje virtual: rect o función que lo devuelve (caret de un editor). */
+    anchorRect?: DOMRect | (() => DOMRect | null);
+    /** Densidad del padding: `compact` (8px) para menús; `none` = lo gestiona el contenido. */
+    padding: IusPopoverPadding;
+    /** Cierra por Esc y clic fuera (opt-in; emite `openChange(false)`). */
+    dismissable: boolean;
+    /** Clase(s) extra del panel (espejo de `popoverClassName`) — la usa Tooltip. */
+    panelClass?: string;
+    /** Espejo de `onOpenChange`. */
+    readonly openChange: EventEmitter<boolean>;
+    private panelTpl;
+    private readonly overlay;
+    private readonly elementRef;
+    private readonly viewContainerRef;
+    private overlayRef;
+    private subs;
+    private removeWindowListeners;
+    private readonly internalOpen;
+    private initialized;
+    /** Lado efectivo tras flip/auto — alimenta `data-side` y la flecha. */
+    protected readonly side: _angular_core.WritableSignal<Side>;
+    protected readonly arrowLeft: _angular_core.WritableSignal<string | null>;
+    protected readonly arrowTop: _angular_core.WritableSignal<string | null>;
+    protected get isOpen(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    protected onHostMouseEnter(): void;
+    protected onHostMouseLeave(): void;
+    protected onHostFocusIn(): void;
+    protected onHostFocusOut(): void;
+    protected onHostClick(): void;
+    private setOpen;
+    private syncOverlay;
+    private attachPanel;
+    private detachPanel;
+    private teardownOverlay;
+    private applyPositionStrategy;
+    private buildPositionStrategy;
+    private resolveOrigin;
+    /**
+     * Placement → lista de posiciones CDK: la preferida primero y su opuesta
+     * como fallback (flip del golden). `auto` ordena los 4 lados por espacio
+     * disponible alrededor del ancla, como `autoPlace` del golden.
+     */
+    private buildPositions;
+    private sidesBySpace;
+    private position;
+    private sideOfPosition;
+    /** Rabito centrado sobre el ancla, con clamp [12, tamaño-24] (golden). */
+    private updateArrow;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverComponent, "ius-popover", never, { "title": { "alias": "title"; "required": false; }; "content": { "alias": "content"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "open": { "alias": "open"; "required": false; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; }; "showArrow": { "alias": "showArrow"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "anchorRect": { "alias": "anchorRect"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "dismissable": { "alias": "dismissable"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*", "[iusPopoverContent]"], true, never>;
+    static ngAcceptInputType_offset: unknown;
+    static ngAcceptInputType_defaultOpen: unknown;
+    static ngAcceptInputType_showArrow: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_dismissable: unknown;
+}
+
+/** Tamaño del texto — small 12/16 · medium 14/20 (default) · large 16/22. */
+type IusTextButtonSize = 'small' | 'medium' | 'large';
+/** `type` nativo del `<button>`. */
+type IusTextButtonType = 'button' | 'submit' | 'reset';
+interface SizePreset {
+    fs: string;
+    lh: string;
+    icon: string;
+    gap: string;
+}
+/**
+ * TextButton — Ius Design v2.
+ *
+ * Botón **solo texto** para acciones de bajo peso visual (links contextuales,
+ * "Ver más", "Cancelar", navegación inline). Sin fondo, borde ni padding:
+ * hereda el alto de la tipografía. El único cambio por estado es el color
+ * (default → hover primary-500 → pressed primary-600 → disabled).
+ *
+ * Foco por `outline` (info-200, offset 2, radius sm) — única excepción del
+ * sistema, no usa box-shadow (ng-spec §6). Para acciones destructivas NO usar
+ * este componente: `ius-button variant="tertiary"` con color danger.
+ *
+ * Nota: el `state` de la spec ("solo demos") se omite de la API pública —
+ * mismo criterio que Button/TextField. El playground congela hover/pressed
+ * con el atributo `data-force` en el host (solo CSS).
+ */
+declare class TextButtonComponent {
+    /** Texto del botón. Tiene prioridad sobre el contenido proyectado. */
+    label?: string;
+    /** Ligadura Material Symbols Rounded a la izquierda. */
+    prefixIcon?: string;
+    /** Ligadura a la derecha. (Nombre heredado del original — conservar `sufixIcon` para paridad de API.) */
+    sufixIcon?: string;
+    /** Tamaño del preset §5. */
+    size: IusTextButtonSize;
+    /** Deshabilitado (`disabled` nativo + `aria-disabled`). */
+    disabled: boolean;
+    /** `type` del `<button>` nativo. */
+    type: IusTextButtonType;
+    /**
+     * Passthrough `aria-expanded`/`aria-controls` al `<button>` (equivalente
+     * Angular del `...rest` del golden; los usa ShowMore al componer).
+     */
+    ariaExpanded?: boolean;
+    ariaControls?: string;
+    /** Emite al pulsar. (No `click`: colisiona con el evento nativo del host.) */
+    readonly clicked: EventEmitter<MouseEvent>;
+    protected get preset(): SizePreset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextButtonComponent, "ius-text-button", never, { "label": { "alias": "label"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "sufixIcon": { "alias": "sufixIcon"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "ariaExpanded": { "alias": "ariaExpanded"; "required": false; }; "ariaControls": { "alias": "ariaControls"; "required": false; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Alineación del disparador dentro de su fila. */
+type IusShowMoreAlign = 'center' | 'start' | 'end' | 'block';
+/**
+ * ShowMore — Ius Design v2.
+ *
+ * **Solo el disparador** "Mostrar N más ⌄ / Mostrar menos ⌃": el
+ * recorte/expansión de la lista lo maneja el consumidor (`expanded` es
+ * controlado y `toggle` pide alternar). Compone `ius-text-button`.
+ * Acción suelta → TextButton; paginar tablas → Pagination.
+ *
+ * `collapsible=false` = revelado de una vía: tras expandir, el control
+ * desaparece (espejo del `return null` del golden).
+ */
+declare class ShowMoreComponent {
+    /** Estado expandido (controlado por el consumidor). */
+    expanded: boolean;
+    /** Arma "Mostrar N más"; sin él, "Mostrar más". */
+    remaining?: number;
+    /** Override del label colapsado. */
+    moreLabel?: string;
+    /** Override del label expandido. */
+    lessLabel: string;
+    /** Si `false`, tras expandir el control desaparece (una vía). */
+    collapsible: boolean;
+    /** Tamaño del TextButton compuesto. */
+    size: IusTextButtonSize;
+    /** Alineación; `block` estira el botón al 100 %. */
+    align: IusShowMoreAlign;
+    /** id del contenedor que controla (`aria-controls`). */
+    ariaControls?: string;
+    /** Pide alternar (original `onToggle`). */
+    readonly toggle: EventEmitter<MouseEvent>;
+    protected get label(): string;
+    /** Revelado de una vía consumado → el control se oculta. */
+    protected get hidden(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShowMoreComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShowMoreComponent, "ius-show-more", never, { "expanded": { "alias": "expanded"; "required": false; }; "remaining": { "alias": "remaining"; "required": false; }; "moreLabel": { "alias": "moreLabel"; "required": false; }; "lessLabel": { "alias": "lessLabel"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "size": { "alias": "size"; "required": false; }; "align": { "alias": "align"; "required": false; }; "ariaControls": { "alias": "ariaControls"; "required": false; }; }, { "toggle": "toggle"; }, never, never, true, never>;
+    static ngAcceptInputType_expanded: unknown;
+    static ngAcceptInputType_collapsible: unknown;
+}
+
+/** Cómo abre el tooltip; `hover` también responde a focus de teclado. */
+type IusTooltipTrigger = 'hover' | 'focus' | 'manual';
+/**
+ * Tooltip — Ius Design v2.
+ *
+ * Etiqueta breve en hover/focus para nombrar controles icon-only, aclarar
+ * texto truncado o dar una pista terse. **Compone `ius-popover`** (mismo
+ * motor de anclaje/flip/auto) con visual **oscuro compacto sin título**
+ * (`panelClass="ius-tooltip"`; la piel vive en el SCSS del Popover).
+ *
+ * Sin contenido interactivo. Ayuda con título+párrafo o mini-menú → Popover;
+ * aviso accionable → Alert; onboarding → Tour/Coachmark.
+ *
+ * Sin `label` no hay burbuja: el trigger proyectado pasa tal cual (el
+ * popover queda `disabled`), espejo del `return children` del golden.
+ */
+declare class TooltipComponent {
+    /** Texto breve; vacío = sin burbuja. */
+    label?: string;
+    /** Colocación (misma escala del Popover); `auto` = lado con más espacio. */
+    placement: IusPopoverPlacement;
+    /** `hover` (incluye focus de teclado) · `focus` · `manual`. */
+    trigger: IusTooltipTrigger;
+    /** Distancia trigger↔burbuja. */
+    offset: number;
+    /** Sin rabito por defecto. */
+    showArrow: boolean;
+    /** Nunca abre. */
+    disabled: boolean;
+    /** Modo controlado (undefined = no controlado). */
+    open?: boolean;
+    /** Estado inicial del modo no controlado. */
+    defaultOpen: boolean;
+    /** Espejo de `onOpenChange`. */
+    readonly openChange: EventEmitter<boolean>;
+    protected get effectiveDisabled(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "ius-tooltip", never, { "label": { "alias": "label"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "showArrow": { "alias": "showArrow"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "open": { "alias": "open"; "required": false; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_offset: unknown;
+    static ngAcceptInputType_showArrow: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_defaultOpen: unknown;
+}
+
+/** Tamaño del campo — small ~34 · medium ~40 (default) · large ~48px. */
+type IusTextFieldSize = 'small' | 'medium' | 'large';
+/** `type` nativo soportado por el input. */
+type IusTextFieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search';
+/**
+ * TextField — Ius Design v2.
+ *
+ * Campo de texto base (BASE de la familia de inputs de texto). Wrapper `.ius-tf`
+ * con label + caja del input (+ prefixIcon + clear) + helpText/errorText.
+ * Cubre 5 estados (Default · Hovered · Focused · Focused-Error · Disabled) y
+ * 3 tamaños. Implementa `ControlValueAccessor` completo para integrarse con
+ * `[(ngModel)]` / `formControl`.
+ *
+ * `showIconHelp` compone `ius-popover` (título + contenido en hover/focus
+ * sobre la pastilla "?"), igual que la spec original. API pública intacta.
+ */
+declare class TextFieldComponent implements ControlValueAccessor {
+    /** Label sobre el input (con `:` final). Sin label si se omite. */
+    label?: string;
+    /** Placeholder dentro del input. */
+    placeholder?: string;
+    /** Punto rojo (•) a la izquierda del label. */
+    required: boolean;
+    /** Ícono Material Symbols Rounded a la izquierda del input. */
+    prefixIcon?: string;
+    /** Forzar visibilidad del botón de limpiar. Por defecto: auto (visible con valor). */
+    showClear?: boolean;
+    /** Línea de ayuda bajo el campo (estado normal). */
+    helpText?: string;
+    /** Reemplaza `helpText` cuando `error` es `true`. */
+    errorText?: string;
+    /** Mostrar/ocultar la línea de ayuda. */
+    showHelpText: boolean;
+    /** Pastilla "?" junto al label. */
+    showIconHelp: boolean;
+    /** Título del contenido de ayuda (popover). */
+    iconHelpTitle?: string;
+    /** Cuerpo del contenido de ayuda (popover). */
+    iconHelpContent?: string;
+    /** Estado de error (colores + errorText). */
+    error: boolean;
+    /** `name` del input. */
+    name?: string;
+    /** `type` del input. La variación password enmascara y agrega el toggle de revelado. */
+    type: IusTextFieldType;
+    private readonly sizeState;
+    set size(value: IusTextFieldSize);
+    get size(): IusTextFieldSize;
+    private readonly disabledState;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    /** Además del CVA: notifica cada cambio de valor. */
+    readonly valueChange: EventEmitter<string>;
+    /** Al pulsar el botón de limpiar (×). */
+    readonly cleared: EventEmitter<void>;
+    protected readonly value: _angular_core.WritableSignal<string>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly revealed: _angular_core.WritableSignal<boolean>;
+    protected readonly inputId: string;
+    protected readonly helpId: string;
+    private onChange;
+    private onTouched;
+    protected get isPassword(): boolean;
+    protected get inputType(): string;
+    protected get hint(): string | undefined;
+    protected get showHint(): boolean;
+    protected get showClearComputed(): boolean;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInput(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected toggleReveal(): void;
+    protected clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextFieldComponent, "ius-text-field", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "showHelpText": { "alias": "showHelpText"; "required": false; }; "showIconHelp": { "alias": "showIconHelp"; "required": false; }; "iconHelpTitle": { "alias": "iconHelpTitle"; "required": false; }; "iconHelpContent": { "alias": "iconHelpContent"; "required": false; }; "error": { "alias": "error"; "required": false; }; "name": { "alias": "name"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; "cleared": "cleared"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_showHelpText: unknown;
+    static ngAcceptInputType_showIconHelp: unknown;
+    static ngAcceptInputType_error: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Lado de casilla: small 44 · medium 48 (default) · large 56 px. */
+type IusCodeFieldSize = 'small' | 'medium' | 'large';
+/**
+ * CodeField — Ius Design v2.
+ *
+ * Variación **segmentada** de TextField: una casilla por carácter (OTP / 2FA /
+ * PIN). Hereda el wrapper `.ius-tf` (label + required + iconHelp + helpText/
+ * errorText), los 5 estados y el botón de limpiar. Fuente de verdad:
+ * `CodeField.jsx` + `CodeField.ng-spec.md` (delta sobre TextField).
+ *
+ * Comportamiento: auto-avance al escribir, `Backspace` en casilla vacía
+ * retrocede, pegar distribuye la cadena, flechas navegan. Implementa
+ * `ControlValueAccessor` (el valor es la cadena completa concatenada).
+ *
+ * Nota: las clases `.ius-tf__*` (label/hint) se replican en el SCSS de este
+ * componente porque bajo ViewEncapsulation.Emulated las de TextField no
+ * alcanzan a otro componente. `showIconHelp` usa `title` nativo como respaldo
+ * (igual que TextField) hasta que exista `ius-popover`.
+ */
+declare class CodeFieldComponent implements ControlValueAccessor {
+    /** Label sobre las casillas (con `:` final). */
+    label?: string;
+    /** Punto rojo (•) a la izquierda del label. */
+    required: boolean;
+    /** Pastilla "?" junto al label (respaldo: `title` nativo). */
+    showIconHelp: boolean;
+    /** Título del contenido de ayuda. */
+    iconHelpTitle?: string;
+    /** Cuerpo del contenido de ayuda. */
+    iconHelpContent?: string;
+    /** Línea de ayuda bajo el campo. */
+    helpText?: string;
+    /** Reemplaza `helpText` cuando `error` es `true`. */
+    errorText?: string;
+    /** Mostrar/ocultar la línea de ayuda. */
+    showHelpText: boolean;
+    /** Carácter guía en casilla vacía. */
+    placeholderChar: string;
+    /** Solo `0-9` + `inputMode="numeric"`. */
+    numeric: boolean;
+    /** Oculta con `•` (`type="password"`), para PIN sensibles. */
+    mask: boolean;
+    /** Estado de error (colores + errorText). */
+    error: boolean;
+    /** `name` base del grupo de casillas. */
+    name?: string;
+    /** Forzar visibilidad del botón de limpiar. Por defecto: auto (con valor). */
+    showClear?: boolean;
+    private readonly lengthState;
+    /** Nº de casillas. */
+    set length(value: number);
+    get length(): number;
+    private readonly sizeState;
+    set size(value: IusCodeFieldSize);
+    get size(): IusCodeFieldSize;
+    private readonly disabledState;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    /** Cadena completa concatenada (original `onChange`). */
+    readonly valueChange: EventEmitter<string>;
+    /** Al llenar todas las casillas (original `onComplete`). */
+    readonly completed: EventEmitter<string>;
+    /** Al pulsar el botón de limpiar. */
+    readonly cleared: EventEmitter<void>;
+    protected readonly chars: _angular_core.WritableSignal<string[]>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly indexes: _angular_core.Signal<number[]>;
+    protected readonly baseId: string;
+    private readonly cellRefs;
+    private onChange;
+    private onTouched;
+    protected get hint(): string | undefined;
+    protected get showHint(): boolean;
+    protected get helpIconTitle(): string | undefined;
+    protected get showClearComputed(): boolean;
+    protected cellAria(i: number): string;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private sanitize;
+    private focusCell;
+    private commit;
+    private setCharAt;
+    protected onInput(i: number, event: Event): void;
+    protected onKeyDown(i: number, event: KeyboardEvent): void;
+    protected onPaste(i: number, event: ClipboardEvent): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodeFieldComponent, "ius-code-field", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showIconHelp": { "alias": "showIconHelp"; "required": false; }; "iconHelpTitle": { "alias": "iconHelpTitle"; "required": false; }; "iconHelpContent": { "alias": "iconHelpContent"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "showHelpText": { "alias": "showHelpText"; "required": false; }; "placeholderChar": { "alias": "placeholderChar"; "required": false; }; "numeric": { "alias": "numeric"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "error": { "alias": "error"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "length": { "alias": "length"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; "completed": "completed"; "cleared": "cleared"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_showIconHelp: unknown;
+    static ngAcceptInputType_showHelpText: unknown;
+    static ngAcceptInputType_numeric: unknown;
+    static ngAcceptInputType_mask: unknown;
+    static ngAcceptInputType_error: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Tono del aro: marca + semánticos + 6 hues de fruta (12 en total). */
+type CountdownRingTone = 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'neutral' | 'durazno' | 'banano' | 'sandia' | 'arandano' | 'uva' | 'aguacate';
+/** Tamaño del aro: small 18 · medium 24 (default) · large 34 px. */
+type CountdownRingSize = 'small' | 'medium' | 'large';
+interface RingDim {
+    d: number;
+    s: number;
+}
+/**
+ * CountdownRing — Ius Design v2 (familia feedback).
+ *
+ * Aro de progreso temporal (`<svg>` decorativo). **Controlado** por `progress`
+ * (comparte reloj con `Countdown`) o corre su propio reloj con `seconds`.
+ * Normal se **llena**; `inverse` arranca lleno y se **vacía** (OTP). No captura
+ * foco ni puntero. Fuente de verdad: `CountdownRing.jsx`.
+ */
+declare class CountdownRingComponent {
+    /** Fracción transcurrida (0→1), controlada por el padre. Ignora el reloj interno. */
+    readonly progress: _angular_core.InputSignal<number | undefined>;
+    /** Duración del reloj interno (modo suelto). */
+    readonly seconds: _angular_core.InputSignal<number | undefined>;
+    /** Corre el reloj interno. Ignorado si hay `progress`. */
+    readonly running: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Congela conservando lo transcurrido. */
+    readonly paused: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Arranca lleno y se vacía. */
+    readonly inverse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Tono (12). */
+    readonly tone: _angular_core.InputSignal<CountdownRingTone>;
+    /** Tamaño del aro. */
+    readonly size: _angular_core.InputSignal<CountdownRingSize>;
+    /** Etiqueta accesible. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Al llegar a 0 (solo reloj interno). */
+    readonly completed: _angular_core.OutputEmitterRef<void>;
+    private readonly clock;
+    protected readonly isControlled: _angular_core.Signal<boolean>;
+    protected readonly dim: _angular_core.Signal<RingDim>;
+    protected readonly ringR: _angular_core.Signal<number>;
+    protected readonly toneVars: _angular_core.Signal<{
+        arc: string;
+        trk: string;
+    }>;
+    /** Fracción transcurrida 0→1 (controlada o del reloj interno). */
+    private readonly elapsed;
+    /** Largo del arco 0→100 (normal llena; inverse vacía). */
+    protected readonly arcLen: _angular_core.Signal<number>;
+    protected readonly dashArray: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CountdownRingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CountdownRingComponent, "ius-countdown-ring", never, { "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "seconds": { "alias": "seconds"; "required": false; "isSignal": true; }; "running": { "alias": "running"; "required": false; "isSignal": true; }; "paused": { "alias": "paused"; "required": false; "isSignal": true; }; "inverse": { "alias": "inverse"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "completed": "completed"; }, never, ["*"], true, never>;
+}
+
+/** Formato del tiempo. */
+type CountdownFormat = 'auto' | 'mm:ss' | 'hh:mm:ss' | 'ss';
+/** Dirección del reloj. */
+type CountdownDirection = 'down' | 'up';
+/**
+ * Countdown — Ius Design v2 (familia feedback).
+ *
+ * Lectura de tiempo en vivo (cronómetro). Regresiva por defecto (reenvío de
+ * OTP, sesiones por expirar) o ascendente (`up`). Etiqueta gris + tiempo tonal
+ * en negrita `tabular-nums`, con aro opcional (`showRing`) que **comparte el
+ * mismo reloj** (le pasa `progress`). Fuente de verdad: `Countdown.jsx`.
+ */
+declare class CountdownComponent {
+    /** Duración total en segundos. */
+    readonly seconds: _angular_core.InputSignal<number>;
+    /** Regresiva (`down`) / ascendente (`up`). */
+    readonly direction: _angular_core.InputSignal<CountdownDirection>;
+    /** Corre el reloj. */
+    readonly running: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Congela conservando lo transcurrido. */
+    readonly paused: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Formato del tiempo. */
+    readonly format: _angular_core.InputSignal<CountdownFormat>;
+    /** Sufijo tras el tiempo (`00:59s`). */
+    readonly suffix: _angular_core.InputSignal<string>;
+    /** Texto guía a la izquierda (gris). */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Muestra el aro sincronizado. */
+    readonly showRing: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Lado del aro. */
+    readonly ringPlacement: _angular_core.InputSignal<"start" | "end">;
+    /** Sentido del aro (por defecto: regresiva vacía, ascendente llena). */
+    readonly ringInverse: _angular_core.InputSignal<boolean | undefined>;
+    /** Tono del número y del aro. */
+    readonly tone: _angular_core.InputSignal<CountdownRingTone>;
+    /** Tamaño. */
+    readonly size: _angular_core.InputSignal<CountdownRingSize>;
+    /** Etiqueta accesible. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Al llegar al total (regresiva → 0). */
+    readonly completed: _angular_core.OutputEmitterRef<void>;
+    private readonly clock;
+    private readonly totalMs;
+    /** Fracción transcurrida 0→1 (para el aro). */
+    protected readonly fraction: _angular_core.Signal<number>;
+    private readonly remainingSec;
+    private readonly elapsedSec;
+    protected readonly text: _angular_core.Signal<string>;
+    protected readonly done: _angular_core.Signal<boolean>;
+    protected readonly ringInv: _angular_core.Signal<boolean>;
+    protected readonly numColor: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CountdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CountdownComponent, "ius-countdown", never, { "seconds": { "alias": "seconds"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "running": { "alias": "running"; "required": false; "isSignal": true; }; "paused": { "alias": "paused"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showRing": { "alias": "showRing"; "required": false; "isSignal": true; }; "ringPlacement": { "alias": "ringPlacement"; "required": false; "isSignal": true; }; "ringInverse": { "alias": "ringInverse"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "completed": "completed"; }, never, never, true, never>;
+}
+
+/** Tono del Alert (6 familias). */
+type AlertTone = 'info' | 'success' | 'warning' | 'danger' | 'neutral' | 'primary';
+/** Tratamiento de fondo. */
+type AlertVariant = 'soft' | 'gradient' | 'outline' | 'solid';
+/** Tamaño. */
+type AlertSize = 'small' | 'medium' | 'large';
+/**
+ * Marca la fila de acciones al pie del Alert. Úsalo en el elemento contenedor:
+ * `<div iusAlertActions><ius-button …/></div>`. Excluyente con `iusAlertTrailing`.
+ */
+declare class IusAlertActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IusAlertActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IusAlertActionsDirective, "[iusAlertActions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marca la acción inline a la derecha (centrada) del Alert:
+ * `<div iusAlertTrailing><ius-button …/></div>`. Excluyente con `iusAlertActions`.
+ */
+declare class IusAlertTrailingDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IusAlertTrailingDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IusAlertTrailingDirective, "[iusAlertTrailing]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Alert — Ius Design v2 (familia feedback).
+ *
+ * Mensaje contextual en bloque (banner / callout). 6 tonos × 4 variantes
+ * (soft/gradient/outline/solid), 3 tamaños, ícono (+chip), overline/título/meta,
+ * cuerpo y slots de acción (`trailing` ⊻ `actions`) proyectados. La armonización
+ * on-color de los hijos (Button/Tag) vive en el CSS (`::ng-deep` acotado al
+ * Alert), no en su API. Fuente de verdad: `Alert.jsx` + `Alert.ng-spec.md`.
+ *
+ * No es para feedback efímero (→ Toast) ni error de validación de campo
+ * (→ el input). El briefing proactivo de IA es `Insight`, no Alert.
+ */
+declare class AlertComponent {
+    /** Tono: fija tinte, borde, color de ícono/título y degradado. */
+    readonly tone: _angular_core.InputSignal<AlertTone>;
+    /** Tratamiento de fondo. */
+    readonly variant: _angular_core.InputSignal<AlertVariant>;
+    /** Tamaño. */
+    readonly size: _angular_core.InputSignal<AlertSize>;
+    /** Estilo del borde. */
+    readonly border: _angular_core.InputSignal<"solid" | "none" | "dashed">;
+    /** Título tonal en negrita. */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Línea superior breve (uppercase). */
+    readonly overline: _angular_core.InputSignal<string | undefined>;
+    /** Ligadura Material Symbols; `false` oculta el ícono; omitir = default por tono. */
+    readonly icon: _angular_core.InputSignal<string | false | undefined>;
+    /** Envuelve el ícono en chip cuadrado tonal (auto en `solid`). */
+    readonly iconChip: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Texto tenue a la derecha del encabezado. */
+    readonly meta: _angular_core.InputSignal<string | undefined>;
+    /** Muestra el botón × de cierre. */
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** aria-label del cierre. */
+    readonly closeLabel: _angular_core.InputSignal<string>;
+    /** Divisor sobre la fila de acciones. */
+    readonly actionsDivider: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Alineación (auto: `center` si hay `trailing` sin `actions`). */
+    readonly align: _angular_core.InputSignal<"start" | "center" | undefined>;
+    /** `status` (default, no interrumpe) o `alert` (asertivo). */
+    readonly role: _angular_core.InputSignal<"status" | "alert">;
+    /** Al pulsar × (original: `onClose`). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly actionsRef;
+    private readonly trailingRef;
+    protected readonly hasActions: _angular_core.Signal<boolean>;
+    protected readonly hasTrailing: _angular_core.Signal<boolean>;
+    /** trailing y actions son excluyentes: si hay ambos, gana actions. */
+    protected readonly showTrailing: _angular_core.Signal<boolean>;
+    protected readonly computedAlign: _angular_core.Signal<"start" | "center">;
+    protected readonly iconName: _angular_core.Signal<string | null>;
+    protected readonly chip: _angular_core.Signal<boolean>;
+    protected readonly showHead: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertComponent, "ius-alert", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "overline": { "alias": "overline"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconChip": { "alias": "iconChip"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "actionsDivider": { "alias": "actionsDivider"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, ["actionsRef", "trailingRef"], ["*", "[iusAlertActions]", "[iusAlertTrailing]"], true, never>;
+}
+
+/** Una pieza de arte: viewBox + markup interno del <svg> (paths, gradientes). */
+interface IllustrationEntry {
+    viewBox: string;
+    inner: string;
+}
+/** Nombres de ilustración del sistema (98 piezas). La capa semántica
+ * (situación → nombre) vive en IllustrationCatalog (aún sin portar). */
+type IllustrationName = 'emptyTray' | 'emptyBox' | 'screenError' | 'error404' | 'unplugged' | 'webMaintenance' | 'launchRocketScreen' | 'rocketProgress' | 'userDisplayOk' | 'shieldSecurity' | 'verifyShield' | 'brokenShield' | 'securityShieldComplete' | 'otpPadlock' | 'emailReadSecure' | 'contactCard' | 'portfolioUser' | 'addGroup' | 'userChoice' | 'userConnection' | 'meeting' | 'gearsUser' | 'gearTransferUser' | 'gearCircularGroup' | 'chartHierarchy' | 'eyeRingChart' | 'apiServices' | 'attachment' | 'cashPayment' | 'trash' | 'accountBalance' | 'agreementOk' | 'aiBrain' | 'ai' | 'approvedDoc' | 'award' | 'balance' | 'banking' | 'barChart' | 'bellAlert' | 'billingMachine' | 'briefcase' | 'budget' | 'chatBot' | 'chronology' | 'codeLaw' | 'corporateFare' | 'corruptFile' | 'creditCardScreen' | 'cv' | 'desert' | 'diagram' | 'directory' | 'docShieldOk' | 'docShieldGavel' | 'donutChart' | 'ebook' | 'emailPc' | 'emptyFolder' | 'statistics' | 'folderManagement' | 'folderShield' | 'futuristicBuilding' | 'gavel' | 'globalNetwork' | 'handUp' | 'handsetSound' | 'lecternPerson' | 'legalBook' | 'library' | 'lightbulb' | 'lineChart' | 'linearChronology' | 'medal' | 'notes' | 'padlock' | 'paintCan' | 'pcInfo' | 'personKey' | 'pipeline' | 'plane' | 'postbox' | 'profile' | 'pyramid' | 'sandglassPay' | 'searchLens' | 'schedule' | 'screenGraph' | 'startup' | 'stepsNumbered' | 'steps' | 'store' | 'support' | 'subscription' | 'targetAudience' | 'target' | 'trade' | 'warehouse';
+/** Lista de los 98 nombres (orden del catálogo). */
+declare const ILLUSTRATION_NAMES: IllustrationName[];
+/** Arte horneado por nombre. */
+declare const ILLUSTRATIONS: Record<IllustrationName, IllustrationEntry>;
+
+/** Tamaño: `small` 64 · `medium` 96 (default) · `large` 140 px, o un número en px. */
+type IllustrationSize = 'small' | 'medium' | 'large' | number;
+/**
+ * Illustration — Ius Design v2 (familia feedback).
+ *
+ * Primitiva de **render** de ilustraciones "spot" (vacío, error, éxito,
+ * seguridad, jurídico, finanzas…). Dibuja un `<svg role="img">` por `name`.
+ * Paleta de arte propia (periwinkle/lima) horneada en los SVG — NO consume
+ * tokens de color del DS (ver Illustration.ng-spec.md §1).
+ *
+ * La capa de **significado** (situación → nombre) vive en el foundation
+ * `IllustrationCatalog` (aún sin portar). Para iconografía pequeña de UI usar
+ * Material Symbols (`.ius-icon`), no esto.
+ *
+ * Namespacing: los IDs de gradiente vienen prefijados por pieza
+ * (`IUSIL_<name>_*`); aquí se les añade un **sufijo por instancia** para que
+ * varias ilustraciones convivan en la misma página sin colisión de `<defs>`.
+ *
+ * Nota de datos: la data (`illustrations.data.ts`) es un port PARCIAL (58/98):
+ * el original supera el tope de lectura del MCP. Los nombres no incluidos
+ * renderizan el placeholder hasta reemplazar la data por el verbatim completo.
+ */
+declare class IllustrationComponent {
+    private readonly sanitizer;
+    /** ID único por instancia, para el sufijo de gradientes. */
+    private readonly instanceId;
+    private _name;
+    /** Qué ilustración renderizar. Ver `IllustrationCatalog` para la semántica. */
+    set name(value: IllustrationName);
+    get name(): IllustrationName;
+    private _size;
+    set size(value: IllustrationSize);
+    get size(): IllustrationSize;
+    /** Etiqueta accesible (`role="img"`). Default: el `name`. */
+    title?: string;
+    protected viewBox: string;
+    protected safeInner: SafeHtml;
+    protected hasEntry: boolean;
+    /** Lado en px resuelto desde `size`. */
+    protected get px(): number;
+    protected get ariaLabel(): string;
+    private rebuild;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IllustrationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IllustrationComponent, "ius-illustration", never, { "name": { "alias": "name"; "required": true; }; "size": { "alias": "size"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Tamaño de la casilla — small 16 · medium 20 (default) · large 24 px. */
+type IusCheckboxSize = 'small' | 'medium' | 'large';
+/** Lado del label respecto a la casilla. */
+type IusCheckboxLabelPosition = 'left' | 'right';
+/**
+ * Checkbox — Ius Design v2.
+ *
+ * Casilla de selección (BASE de la molécula de toggle: halo + estados + CVA
+ * booleano — patrón que reusarán Switch y Radio). Marca en navy (Primary-900)
+ * con check blanco; halo circular gris en hover y azul en pressed/focus.
+ * Soporta estado `indeterminate` (guion), que **prevalece visualmente** sobre
+ * `checked`. Implementa `ControlValueAccessor` (`boolean`) para integrarse con
+ * `[(ngModel)]` / `formControl`.
+ *
+ * Nota: `showIconHelp` compone `Popover` en la spec original (React); ese
+ * componente aún no está portado en este monorepo, así que aquí se usa un
+ * `title` nativo como respaldo accesible (mismo criterio que TextField).
+ * Reemplazar por `ius-popover` cuando exista, sin cambiar la API pública.
+ *
+ * `state` (`idle | hover | pressed | focused | disabled`) de la spec es SOLO
+ * para demos/especímenes → se omite de la API pública; el playground congela
+ * un estado visual con el atributo `data-force` (igual que TextField).
+ */
+declare class CheckboxComponent implements ControlValueAccessor {
+    /** Texto junto a la casilla. Sin label si se omite. */
+    label?: string;
+    /** Lado del label respecto a la casilla. */
+    labelPosition: IusCheckboxLabelPosition;
+    /** Pastilla "?" junto al label. */
+    showIconHelp: boolean;
+    /** Título del contenido de ayuda (popover). */
+    iconHelpTitle?: string;
+    /** Cuerpo del contenido de ayuda (popover). */
+    iconHelpContent?: string;
+    /** `name` del input. */
+    name?: string;
+    /** `value` del input. */
+    value?: string;
+    private readonly sizeState;
+    set size(value: IusCheckboxSize);
+    get size(): IusCheckboxSize;
+    private readonly checkedState;
+    set checked(value: boolean);
+    get checked(): boolean;
+    /** Estado inicial no controlado (alias de `checked` como valor inicial). */
+    set defaultChecked(value: boolean);
+    /** Estado intermedio (guion); prevalece visualmente sobre `checked`. */
+    indeterminate: boolean;
+    private readonly disabledState;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    /** Callback con el nuevo booleano (original `onChange(checked)`; nunca `change`). */
+    readonly checkedChange: EventEmitter<boolean>;
+    protected readonly inputId: string;
+    private onChange;
+    private onTouched;
+    /** Glifo Material Symbols dentro de la casilla. */
+    protected get glyph(): string;
+    protected get ariaChecked(): 'mixed' | 'true' | 'false';
+    protected get helpIconTitle(): string | undefined;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onToggle(): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "ius-checkbox", never, { "label": { "alias": "label"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "showIconHelp": { "alias": "showIconHelp"; "required": false; }; "iconHelpTitle": { "alias": "iconHelpTitle"; "required": false; }; "iconHelpContent": { "alias": "iconHelpContent"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "size": { "alias": "size"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+    static ngAcceptInputType_showIconHelp: unknown;
+    static ngAcceptInputType_checked: unknown;
+    static ngAcceptInputType_defaultChecked: unknown;
+    static ngAcceptInputType_indeterminate: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Forma del medallón. `*-outline` = fondo blanco + anillo del color de acento. */
+type IusAvatarShape = 'circle' | 'square' | 'circle-outline' | 'square-outline';
+/** Tamaño — xsmall 24 · small 32 · medium 40 (default) · large 64 px. */
+type IusAvatarSize = 'xsmall' | 'small' | 'medium' | 'large';
+/** Familia de color del relleno (monograma/ícono). `auto` = estable por nombre. */
+type IusAvatarColor = 'auto' | 'info' | 'primary' | 'success' | 'warning' | 'danger' | 'neutral' | 'durazno' | 'banano' | 'sandia' | 'arandano' | 'uva' | 'aguacate';
+/**
+ * Avatar — Ius Design v2.
+ *
+ * Medallón de contacto/usuario/entidad. Prioridad de contenido
+ * **foto → ícono → monograma**. `color="auto"` deriva un color estable del
+ * nombre (hash determinista). Con `editable` se renderiza como control
+ * enfocable (role=button) con overlay de edición en hover/focus.
+ *
+ * `state` (`idle | hover | focused`) de la spec es SOLO para demos → se omite de
+ * la API pública; el playground congela el estado con `data-force`.
+ */
+declare class AvatarComponent {
+    /** Texto alternativo de la imagen. */
+    alt?: string;
+    /** Nombre completo: genera iniciales y, con `color=auto`, el color. */
+    name?: string;
+    /** Monograma explícito (sobrescribe las iniciales derivadas de `name`). */
+    monogram?: string;
+    /** Ícono Material Symbols (si no hay foto). */
+    icon?: string;
+    /** Forma del medallón. */
+    shape: IusAvatarShape;
+    /** Tamaño del medallón. */
+    size: IusAvatarSize;
+    /** Familia de color del relleno (monograma/ícono). */
+    color: IusAvatarColor;
+    /** Permite editar: overlay de edición + render enfocable + evento `edit`. */
+    editable: boolean;
+    /** Ícono del overlay de edición. */
+    editIcon: string;
+    /** Etiqueta accesible explícita (anula la derivada). */
+    ariaLabel?: string;
+    /** Solo `editable`: clic o Enter/Espacio sobre el medallón. */
+    readonly edit: EventEmitter<Event>;
+    private readonly imgError;
+    private _src?;
+    /** URL de la fotografía. Prioridad si carga; si falla, cae a ícono/monograma. */
+    set src(value: string | undefined);
+    get src(): string | undefined;
+    protected get hasPhoto(): boolean;
+    /** Prioridad de contenido: foto → ícono → monograma. */
+    protected get variant(): 'photo' | 'icon' | 'mono';
+    protected get resolvedColor(): Exclude<IusAvatarColor, 'auto'>;
+    protected get initials(): string;
+    protected get imgAlt(): string;
+    protected get hostRole(): string | null;
+    private get computedLabel();
+    protected get hostAriaLabel(): string | null;
+    protected onImgError(): void;
+    protected onHostClick(event: MouseEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "ius-avatar", never, { "alt": { "alias": "alt"; "required": false; }; "name": { "alias": "name"; "required": false; }; "monogram": { "alias": "monogram"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "editIcon": { "alias": "editIcon"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "src": { "alias": "src"; "required": false; }; }, { "edit": "edit"; }, never, never, true, never>;
+    static ngAcceptInputType_editable: unknown;
+}
+
+/** Jerarquía visual del IconButton. */
+type IusIconButtonVariant = 'secondary' | 'tertiary';
+/** Tamaño cuadrado — small 28 · medium 36 (default) · large 44 px. */
+type IusIconButtonSize = 'small' | 'medium' | 'large';
+/** Forma del contenedor. */
+type IusIconButtonShape = 'squared' | 'circle';
+/**
+ * IconButton — Ius Design v2.
+ *
+ * Botón icon-only (una sola ligadura Material Symbols Rounded). Dos jerarquías
+ * (`secondary` = fondo neutral + ícono verde; `tertiary` = transparente + ícono
+ * secundario), dos formas (`squared` radio 8 · `circle` radio pill, con borde
+ * outlined en circle·secondary) y tres tamaños (28/36/44). El pressed comparte
+ * el verde de marca (Success-500) salvo circle·tertiary (Primary-900).
+ *
+ * `tooltip` compone `ius-tooltip` (etiqueta en hover/focus, como el golden).
+ * No reemplaza a `ariaLabel`: la etiqueta accesible sigue siendo obligatoria.
+ *
+ * `state` (demos) de la spec se omite de la API pública; el playground congela
+ * el estado con el atributo `data-force` en el host.
+ */
+declare class IconButtonComponent implements OnInit {
+    /** Ligadura Material Symbols Rounded (requerido). Ej. `"add"`, `"close"`. */
+    icon: string;
+    /** Jerarquía visual. */
+    variant: IusIconButtonVariant;
+    /** Tamaño del cuadro. */
+    size: IusIconButtonSize;
+    /** Forma del contenedor. */
+    shape: IusIconButtonShape;
+    /** Deshabilitado. */
+    disabled: boolean;
+    /** `type` del `<button>`. */
+    type: 'button' | 'submit' | 'reset';
+    /** Texto accesible. Si se omite, cae al nombre del ícono (poco descriptivo). */
+    ariaLabel?: string;
+    /** Etiqueta breve en hover/focus (compone `ius-tooltip`). No sustituye a `ariaLabel`. */
+    tooltip?: string;
+    /** Colocación del tooltip. */
+    tooltipPlacement: IusPopoverPlacement;
+    /** Emite al pulsar. Nunca `click` (colisión con el nativo del host). */
+    readonly clicked: EventEmitter<MouseEvent>;
+    ngOnInit(): void;
+    protected get computedLabel(): string;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconButtonComponent, "ius-icon-button", never, { "icon": { "alias": "icon"; "required": true; }; "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Cuenta activa (medallón/nombre). Color auto estable por nombre de cuenta. */
+interface IusNavUserAccount {
+    name?: string;
+    monogram?: string;
+    icon?: string;
+    color?: IusAvatarColor;
+}
+/** Usuario (foto + nombre). */
+interface IusNavUserUser {
+    name?: string;
+    avatar?: string;
+}
+/** Presentación — stacked (cuenta sobre usuario) · single (solo usuario). */
+type IusNavUserLayout = 'stacked' | 'single';
+/**
+ * NavUser — Ius Design v2.
+ *
+ * Control de cuenta + usuario del HeaderBar; abre el UserMenu (este componente
+ * es solo el disparador). Ligero: sin borde ni fondo en reposo, fondo neutro en
+ * hover/pressed/open. `stacked` (default) apila el nombre de cuenta sobre el del
+ * usuario; `single` muestra solo el usuario. Un solo Avatar (foto del usuario).
+ *
+ * `state` (`hover | pressed | open`) de la spec es SOLO para demos → el
+ * playground congela el estado con el atributo `data-state` en el host.
+ */
+declare class NavUserComponent {
+    /** Usuario (foto a la derecha + nombre). */
+    user?: IusNavUserUser;
+    /** Cuenta activa (nombre arriba en `stacked`). */
+    account?: IusNavUserAccount;
+    /** Presentación. */
+    layout: IusNavUserLayout;
+    /** Menú abierto: fondo neutro + chevron/estado abierto. */
+    open: boolean;
+    /** Etiqueta accesible explícita. */
+    ariaLabel?: string;
+    /** Al pulsar (conecta con el UserMenu). Nunca `click`. */
+    readonly clicked: EventEmitter<MouseEvent>;
+    protected get avatarIcon(): string | undefined;
+    protected get hostAriaLabel(): string;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavUserComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavUserComponent, "ius-nav-user", never, { "user": { "alias": "user"; "required": false; }; "account": { "alias": "account"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "open": { "alias": "open"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+    static ngAcceptInputType_open: unknown;
+}
+
+/**
+ * HeaderBar — Ius Design v2.
+ *
+ * Franja superior transversal del ecosistema (identidad de sesión): marca +
+ * módulo a la izquierda; clúster de acciones (ayuda · soporte · agenda ·
+ * notificaciones · apps) + NavUser (cuenta) a la derecha. Compone IconButton y
+ * NavUser. Persiste al navegar; no es breadcrumb (eso va en PageHeader).
+ *
+ * Slots: `logo` (`<… slot="logo">`, fallback = placeholder neutro, no se inventa
+ * logo), `actions` (`<… slot="actions">`, reemplaza el clúster completo),
+ * `appsTemplate` (TemplateRef en vez del IconButton apps, p. ej. AppLauncher
+ * cuando exista). `module` es string (identidad de módulo estable).
+ *
+ * Notas de port:
+ * - Alto 52px según el CSS golden (el prompt menciona 60px; el jsx manda).
+ * - El punto de novedad de notificaciones compone `Insignia dot` en el golden;
+ *   Insignia aún no está portada → se usa un punto inline equivalente.
+ * - Outputs con sufijo `Click` (help/support/… ya son inputs boolean → no se
+ *   puede reusar el nombre; se evita además el nativo `click`).
+ */
+declare class HeaderBarComponent {
+    /** Nombre del módulo activo (identidad estable, NO breadcrumb). */
+    module?: string;
+    /** Mostrar el botón de ayuda. */
+    help: boolean;
+    /** Mostrar el botón de soporte. */
+    support: boolean;
+    /** Mostrar el lanzador de aplicaciones. */
+    apps: boolean;
+    /** Mostrar el ícono de Agenda (eventos próximos). */
+    calendar: boolean;
+    /** Campana con punto de novedad (solo punto, sin contador). Omitir la oculta. */
+    notifications: boolean;
+    /** Nodo a renderizar en lugar del IconButton apps (p. ej. un AppLauncher). Requiere `apps`. */
+    appsTemplate?: TemplateRef<any>;
+    /** Usuario de la cuenta (foto + nombre); se renderiza como NavUser. Omitir oculta el bloque. */
+    user?: IusNavUserUser;
+    /** Cuenta activa (nombre arriba); habilita el layout apilado del NavUser. */
+    account?: IusNavUserAccount;
+    /** Menú de cuenta abierto (estado abierto del NavUser). */
+    accountOpen: boolean;
+    /** Clic en la marca. Sin suscriptor, la marca es estática (sin hover). */
+    readonly brandClick: EventEmitter<MouseEvent>;
+    readonly helpClick: EventEmitter<MouseEvent>;
+    readonly supportClick: EventEmitter<MouseEvent>;
+    readonly appsClick: EventEmitter<MouseEvent>;
+    readonly calendarClick: EventEmitter<MouseEvent>;
+    readonly notificationsClick: EventEmitter<MouseEvent>;
+    readonly accountClick: EventEmitter<MouseEvent>;
+    /** La marca es estática (cursor default, sin hover) si nadie escucha `brandClick`. */
+    protected get brandStatic(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeaderBarComponent, "ius-header-bar", never, { "module": { "alias": "module"; "required": false; }; "help": { "alias": "help"; "required": false; }; "support": { "alias": "support"; "required": false; }; "apps": { "alias": "apps"; "required": false; }; "calendar": { "alias": "calendar"; "required": false; }; "notifications": { "alias": "notifications"; "required": false; }; "appsTemplate": { "alias": "appsTemplate"; "required": false; }; "user": { "alias": "user"; "required": false; }; "account": { "alias": "account"; "required": false; }; "accountOpen": { "alias": "accountOpen"; "required": false; }; }, { "brandClick": "brandClick"; "helpClick": "helpClick"; "supportClick": "supportClick"; "appsClick": "appsClick"; "calendarClick": "calendarClick"; "notificationsClick": "notificationsClick"; "accountClick": "accountClick"; }, never, ["[slot=logo]", "[slot=actions]"], true, never>;
+    static ngAcceptInputType_help: unknown;
+    static ngAcceptInputType_support: unknown;
+    static ngAcceptInputType_apps: unknown;
+    static ngAcceptInputType_calendar: unknown;
+    static ngAcceptInputType_notifications: unknown;
+    static ngAcceptInputType_accountOpen: unknown;
+}
+
+/** Tono del anillo. */
+type IusCircularProgressTone = 'info' | 'primary' | 'success' | 'warning' | 'danger' | 'neutral' | 'brand';
+/** Tamaño — small 22 · medium 30 (default) · large 44 px. */
+type IusCircularProgressSize = 'small' | 'medium' | 'large';
+interface Dim {
+    d: number;
+    s: number;
+}
+/**
+ * CircularProgress — Ius Design v2.
+ *
+ * Anillo de progreso: determinado (`value`) o indeterminado (cometa que gira).
+ * Port del golden CircularProgress.jsx (geometría de dos arcos + gradiente
+ * cometa). La cuenta regresiva (`duration`/countdown, rAF) del golden NO se
+ * porta aún — pendiente; cubre determinado + indeterminado.
+ */
+declare class CircularProgressComponent {
+    value: number;
+    max: number;
+    indeterminate: boolean;
+    tone: IusCircularProgressTone;
+    size: IusCircularProgressSize;
+    showValue: boolean;
+    ariaLabel?: string;
+    protected readonly gid: string;
+    protected get dim(): Dim;
+    protected get r(): number;
+    protected get cx(): number;
+    protected get cy(): number;
+    protected get toneVar(): string;
+    protected get grad(): {
+        strong: string;
+        light: string;
+    };
+    protected get pct(): number;
+    protected get roundedPct(): number;
+    private get half();
+    protected get coloredLen(): number;
+    protected get grayLen(): number;
+    protected get coloredDash(): string;
+    protected get coloredOffset(): number;
+    protected get grayDash(): string;
+    protected get grayOffset(): number;
+    protected get center(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CircularProgressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CircularProgressComponent, "ius-circular-progress", never, { "value": { "alias": "value"; "required": false; }; "max": { "alias": "max"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_indeterminate: unknown;
+    static ngAcceptInputType_showValue: unknown;
+}
+
+/** Modo de presentación. */
+type IusLoadingVariant = 'inline' | 'section' | 'page' | 'overlay';
+/**
+ * Loading — Ius Design v2.
+ *
+ * Orquesta la espera indeterminada (CircularProgress) en 4 modos: inline,
+ * section, page, overlay (capa con scrim sobre `children` proyectados).
+ *
+ * Nota: `brand` compone `LoadingMark` (cometa) en el golden; ese componente aún
+ * no está portado → en modo brand se conserva el CircularProgress y la
+ * superficie con degradado de marca en page/overlay. Reemplazar por
+ * `ius-loading-mark` cuando exista, sin cambiar la API.
+ */
+declare class LoadingComponent {
+    variant: IusLoadingVariant;
+    /** Etiqueta junto/bajo el spinner. `''`/null la oculta. */
+    label: string | null;
+    showLabel: boolean;
+    /** Tono del spinner (ignorado en brand). */
+    tone: IusCircularProgressTone;
+    /** Look de marca (degradado navy→cian en page/overlay). */
+    brand: boolean;
+    /** Tamaño del spinner (default por variante). */
+    size?: IusCircularProgressSize;
+    /** Solo `overlay`: muestra/oculta la capa. */
+    active: boolean;
+    /** Etiqueta accesible del spinner si `label` no es texto. */
+    ariaLabel?: string;
+    protected get sz(): IusCircularProgressSize;
+    /** Lado en px del cometa LoadingMark (modo brand). */
+    protected get markPx(): number;
+    /**
+     * Solo `page` brand pinta la superficie navy (el cometa abre a cian para
+     * despegar del fondo). En section/overlay el scrim es claro → cometa navy.
+     */
+    protected get markSurface(): 'light' | 'dark';
+    protected get spinnerAria(): string;
+    protected get showLabelNode(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoadingComponent, "ius-loading", never, { "variant": { "alias": "variant"; "required": false; }; "label": { "alias": "label"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "brand": { "alias": "brand"; "required": false; }; "size": { "alias": "size"; "required": false; }; "active": { "alias": "active"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_showLabel: unknown;
+    static ngAcceptInputType_brand: unknown;
+    static ngAcceptInputType_active: unknown;
+}
+
+/** Situación por defecto (ícono + tono). */
+type IusEmptyStateVariant = 'no-data' | 'no-results';
+/** Tamaño — escala círculo/tipografía/padding/botones. */
+type IusEmptyStateSize = 'compact' | 'medium' | 'full';
+type IusEmptyStateTone = 'info' | 'primary' | 'success' | 'warning' | 'danger' | 'neutral';
+/** Acción del EmptyState. `onClick` del golden → outputs (primaryClick)/(secondaryClick). */
+interface IusEmptyStateAction {
+    label?: string;
+    icon?: string;
+    variant?: 'primary' | 'outline' | 'secondary' | 'tertiary' | 'danger';
+    dynamic?: boolean;
+    disabled?: boolean;
+}
+/**
+ * EmptyState — Ius Design v2.
+ *
+ * Estado de "sin datos": ícono en círculo de tono suave (o ilustración spot) +
+ * título + descripción + 0–2 acciones (Button). Para resultado/estado de página
+ * completa (éxito/error/404/403/500) → StatusState.
+ *
+ * Compone `ius-button` (acciones) e `ius-illustration` (visual opcional, resuelto
+ * por situación vía IllustrationCatalog). `illustration`: `true` autoresuelve por
+ * `variant`; `string` = situación/nombre del catálogo; o un nodo a medida vía
+ * `illustrationTemplate`.
+ */
+declare class EmptyStateComponent {
+    variant: IusEmptyStateVariant;
+    size: IusEmptyStateSize;
+    tone?: IusEmptyStateTone;
+    /** Ligadura Material Symbols. `false` oculta el visual. */
+    icon?: string | false;
+    /** Ilustración spot: `true` autoresuelve por `variant`; `string` = situación/nombre. */
+    illustration?: boolean | string;
+    /** Nodo de ilustración a medida (reemplaza el círculo de ícono y el autoresolve). */
+    illustrationTemplate?: TemplateRef<any>;
+    title?: string;
+    description?: string;
+    /** Acción primaria (Button). String = solo label. */
+    primaryAction?: IusEmptyStateAction | string;
+    /** Acción secundaria (Button secondary). String = solo label. */
+    secondaryAction?: IusEmptyStateAction | string;
+    /** Escape hatch: nodo de acciones a medida (reemplaza primary/secondary). */
+    actionsTemplate?: TemplateRef<any>;
+    role: string;
+    readonly primaryClick: EventEmitter<MouseEvent>;
+    readonly secondaryClick: EventEmitter<MouseEvent>;
+    private get preset();
+    protected get effTone(): IusEmptyStateTone;
+    protected get iconName(): string | null;
+    protected get btnSize(): 'small' | 'medium' | 'large';
+    protected get illusSize(): 'small' | 'medium' | 'large';
+    /** Nombre de ilustración resuelto desde `illustration` (true/string). */
+    protected get illusName(): IllustrationName | null;
+    protected get hasIllustration(): boolean;
+    protected get hasVisual(): boolean;
+    private norm;
+    protected get primary(): IusEmptyStateAction | null;
+    protected get secondary(): IusEmptyStateAction | null;
+    protected get hasActions(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyStateComponent, "ius-empty-state", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "illustration": { "alias": "illustration"; "required": false; }; "illustrationTemplate": { "alias": "illustrationTemplate"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "primaryAction": { "alias": "primaryAction"; "required": false; }; "secondaryAction": { "alias": "secondaryAction"; "required": false; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; }; "role": { "alias": "role"; "required": false; }; }, { "primaryClick": "primaryClick"; "secondaryClick": "secondaryClick"; }, never, never, true, never>;
+}
+
+/** Resultado/estado de página. */
+type IusStatusKind = 'success' | 'error' | 'not-found' | 'restricted' | 'server-error' | 'maintenance';
+/**
+ * StatusState — Ius Design v2.
+ *
+ * Estado de página completa para el resultado de una acción/navegación: éxito,
+ * error, 404, 403, 500, mantenimiento. Compone EmptyState (`size="full"`). Cada
+ * `status` fija tono, código, ícono y copy por defecto.
+ *
+ * Visual (prioridad): ilustración a medida (`illustrationTemplate`) → numeral
+ * del código (`showCode`) → ícono Material Symbols por status.
+ *
+ * Nota de port: el visual por defecto del golden es la ilustración spot
+ * (`Illustration` resuelta por `resolveIllustration(status)`); `ius-illustration`
+ * aún no está portado, así que por defecto se usa el ícono. Cuando exista, el
+ * default pasará a la ilustración sin cambiar la API (`IllustrationCatalog` ya
+ * está portado en `illustration-catalog.ts`).
+ */
+declare class StatusStateComponent {
+    status: IusStatusKind;
+    code?: string | number;
+    showCode: boolean;
+    title?: string;
+    description?: string;
+    /** Ilustración a medida (reemplaza el visual por defecto). */
+    illustrationTemplate?: TemplateRef<any>;
+    /** Ícono Material Symbols (sobrescribe el del status). */
+    icon?: string;
+    tone?: IusEmptyStateTone;
+    size: IusEmptyStateSize;
+    primaryAction?: IusEmptyStateAction | string;
+    secondaryAction?: IusEmptyStateAction | string;
+    role?: string;
+    readonly primaryClick: EventEmitter<MouseEvent>;
+    readonly secondaryClick: EventEmitter<MouseEvent>;
+    private get cfg();
+    protected get effTone(): IusEmptyStateTone;
+    protected get effCode(): string | null;
+    protected get effRole(): string;
+    protected get effTitle(): string;
+    protected get effDescription(): string;
+    protected get statusIcon(): string;
+    protected get toneVar(): string;
+    /** Se muestra el numeral cuando `showCode` y hay código. */
+    protected get useCode(): boolean;
+    /**
+     * Pieza spot por situación (vía catálogo). El golden la renderiza SIEMPRE a
+     * `size="large"`, desacoplada del prop `size` (que solo escala el layout de
+     * EmptyState), por eso StatusState dibuja la ilustración él mismo y la pasa
+     * como plantilla, en vez de delegar el tamaño a EmptyState.
+     */
+    protected get spotName(): IllustrationName | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusStateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusStateComponent, "ius-status-state", never, { "status": { "alias": "status"; "required": false; }; "code": { "alias": "code"; "required": false; }; "showCode": { "alias": "showCode"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "illustrationTemplate": { "alias": "illustrationTemplate"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "size": { "alias": "size"; "required": false; }; "primaryAction": { "alias": "primaryAction"; "required": false; }; "secondaryAction": { "alias": "secondaryAction"; "required": false; }; "role": { "alias": "role"; "required": false; }; }, { "primaryClick": "primaryClick"; "secondaryClick": "secondaryClick"; }, never, never, true, never>;
+    static ngAcceptInputType_showCode: unknown;
+}
+
+/** Situación semántica → ilustración. Las pantallas piden por intención. */
+declare const ILLUSTRATION_ALIAS: Readonly<Record<string, IllustrationName>>;
+/**
+ * Resuelve una situación semántica o un nombre directo a un nombre de
+ * ilustración válido. `null` si no reconoce ni situación ni nombre.
+ */
+declare function resolveIllustration(key: string | null | undefined): IllustrationName | null;
+
+/** Transición entre imágenes — `fade` (cross-fade) · `kenburns` (fade + zoom lento). */
+type IusCarouselTransition = 'fade' | 'kenburns';
+/** Velo de legibilidad sobre el claim. */
+type IusCarouselOverlay = 'none' | 'gradient' | 'brand';
+/** Orden de reproducción de la galería. */
+type IusCarouselOrder = 'sequential' | 'random';
+/** Ajuste de la imagen dentro del contenedor. */
+type IusCarouselObjectFit = 'cover' | 'contain';
+/** Imagen normalizada de la galería. */
+interface IusCarouselImage {
+    src: string;
+    alt: string;
+}
+/** Entrada aceptada por `images`: URL suelta o `{ src, alt }`. */
+type IusCarouselImageInput = string | {
+    src: string;
+    alt?: string;
+};
+/**
+ *
+ * Galería de imágenes en loop con cross-fade, decorativa full-height panel del
+ * login, con claim de marca + subtítulo + CTA opcionales. La galería es
+ * actualizable por input `images`; el consumidor le da el alto 100%×100%.
+ *
+ * Port Angular nativo de `Carousel.jsx` No es campo de
+ * formulario — sin `ControlValueAccessor`. El CTA se proyecta:
+ * `<button carousel-action>…</button>` dentro de `<ius-carousel>`.
+ */
+declare class CarouselComponent {
+    /** Galería actualizable. Al cambiar, reinicia en la primera imagen. */
+    readonly images: _angular_core.InputSignal<IusCarouselImageInput[]>;
+    /** Claim de marca (Roboto bold, blanco). Sin claim si se omite. */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Subtítulo bajo el claim (Rubik). */
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    /** Tiempo por imagen (ms). */
+    readonly interval: _angular_core.InputSignal<number>;
+    /** Cross-fade o fade + zoom lento del activo. */
+    readonly transition: _angular_core.InputSignal<IusCarouselTransition>;
+    /** Scrim navy vía `color-mix` sobre `--ius-primary-900`. */
+    readonly overlay: _angular_core.InputSignal<IusCarouselOverlay>;
+    /** Indicadores clicables (el activo se ensancha). */
+    readonly dots: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Flechas ‹ › opcionales. */
+    readonly arrows: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** `random` baraja (Fisher–Yates) al montar / cambiar `images`. */
+    readonly order: _angular_core.InputSignal<IusCarouselOrder>;
+    /** Autoavance en loop. */
+    readonly autoPlay: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Repetición al llegar al final. */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Ajuste de la imagen. */
+    readonly objectFit: _angular_core.InputSignal<IusCarouselObjectFit>;
+    /** Pausa el autoplay al hover. */
+    readonly pauseOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Etiqueta de la región (accesibilidad). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Índice visible actual (por si el consumidor sincroniza algo). Nunca `change`. */
+    readonly indexChange: _angular_core.OutputEmitterRef<number>;
+    /** Galería normalizada a `{ src, alt }`. */
+    protected readonly slides: _angular_core.Signal<IusCarouselImage[]>;
+    /** Orden de reproducción (secuencial o barajado). */
+    protected readonly seq: _angular_core.Signal<number[]>;
+    /**
+     * Posición dentro del orden de reproducción. `linkedSignal` la reinicia a 0
+     * cuando cambia el set de imágenes o el orden (espejo del
+     * `useEffect(() => setPos(0), [n, order])` del JSX), y es escribible para la
+     * navegación manual/automática.
+     */
+    protected readonly pos: _angular_core.WritableSignal<number>;
+    /** Índice de la imagen visible (en la galería original). */
+    protected readonly activeIndex: _angular_core.Signal<number>;
+    private readonly paused;
+    constructor();
+    /** Navega a una posición del orden de reproducción (con loop o clamp). */
+    protected go(next: number): void;
+    protected onEnter(): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CarouselComponent, "ius-carousel", never, { "images": { "alias": "images"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "transition": { "alias": "transition"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "dots": { "alias": "dots"; "required": false; "isSignal": true; }; "arrows": { "alias": "arrows"; "required": false; "isSignal": true; }; "order": { "alias": "order"; "required": false; "isSignal": true; }; "autoPlay": { "alias": "autoPlay"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "objectFit": { "alias": "objectFit"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; }, never, ["[carousel-action]"], true, never>;
+}
+
+/** Disposición de la ficha. */
+type DescriptionListLayout = 'inline' | 'stacked' | 'grid';
+/** Tamaño (afecta fs del valor y padding de celda en grid). */
+type DescriptionListSize = 'small' | 'medium';
+/**
+ * Un par etiqueta·valor. `label`/`value` aceptan texto (`string`) o contenido
+ * rico proyectado (`TemplateRef` — Tag, Avatar, EventPill, un mapa…).
+ */
+interface DescriptionListItem {
+    /** Etiqueta (dt). Texto o `TemplateRef`. */
+    label: string | TemplateRef<unknown>;
+    /** Valor (dd). Texto o `TemplateRef`. */
+    value?: string | TemplateRef<unknown>;
+    /** Ícono Material Symbols al lado del **valor** (no de la etiqueta). */
+    icon?: string;
+    /** Hace el valor un enlace real `<a href>`. */
+    href?: string;
+    /** Hace el valor un `<button>` que emite `valueClicked` (si no hay `href`). */
+    clickable?: boolean;
+    /** aria-label del valor navegable cuando el texto no basta. */
+    ariaLabel?: string;
+    /** Fuerza/desactiva `tabular-nums` en este valor (override de `tabularValues`). */
+    tabular?: boolean;
+    /** Solo `grid`: sub-columnas que ocupa la celda de valor. */
+    span?: number;
+}
+/** Payload de `valueClicked`. */
+interface DescriptionListValueClick {
+    item: DescriptionListItem;
+    index: number;
+    event: Event;
+}
+/**
+ * DescriptionList — Ius Design v2 (familia data-display).
+ *
+ * Ficha de datos **solo lectura** (`<dl>/<dt>/<dd>`): pares etiqueta·valor de
+ * una entidad. Es un **compositor**: aloja los valores ricos (Tag, Avatar,
+ * EventPill, mapa) por proyección (`TemplateRef`), no los dibuja. 3 layouts
+ * (inline subgrid · stacked · grid de celdas), navegable (href/clickable), y
+ * densidad por `size` / `--ius-density`. Fuente de verdad: `DescriptionList.jsx`.
+ *
+ * No es para KPI único (→ Stat), fila navegable completa (→ ListCard) ni datos
+ * editables (→ inputs).
+ */
+declare class DescriptionListComponent {
+    /** Pares etiqueta·valor. */
+    readonly items: _angular_core.InputSignal<DescriptionListItem[]>;
+    /** inline (columnas alineadas) · stacked (apilado) · grid (tabla de celdas). */
+    readonly layout: _angular_core.InputSignal<DescriptionListLayout>;
+    /** small (valor fs-sm + celdas compactas) · medium (valor fs-base). */
+    readonly size: _angular_core.InputSignal<DescriptionListSize>;
+    /** Solo grid: pares por fila (los `span` de una fila deben sumar `columns`). */
+    readonly columns: _angular_core.InputSignal<number>;
+    /** Solo inline: valor pegado a la etiqueta (start) o al borde derecho (end). */
+    readonly valueAlign: _angular_core.InputSignal<"start" | "end">;
+    /** Hairline entre filas (inline/stacked; ignorado en grid). */
+    readonly divider: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** `tabular-nums` en valores string (override por ítem con `item.tabular`). */
+    readonly tabularValues: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Solo inline: ancho de la columna de etiquetas. */
+    readonly termWidth: _angular_core.InputSignal<string>;
+    /** Al activar un valor `clickable` (sin href). El caso `href` es un `<a>` nativo. */
+    readonly valueClicked: _angular_core.OutputEmitterRef<DescriptionListValueClick>;
+    protected readonly isGrid: _angular_core.Signal<boolean>;
+    /** grid-template-columns inline según `columns` (no `repeat(var())`). */
+    protected readonly gridCols: _angular_core.Signal<string | null>;
+    protected isTemplate(v: unknown): v is TemplateRef<unknown>;
+    protected asTemplate(v: unknown): TemplateRef<unknown>;
+    protected isTab(item: DescriptionListItem): boolean;
+    /** grid-column de la celda de valor: `span (2*span - 1)`. */
+    protected gridColSpan(item: DescriptionListItem): string;
+    protected onValueClick(item: DescriptionListItem, event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DescriptionListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DescriptionListComponent, "ius-description-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "valueAlign": { "alias": "valueAlign"; "required": false; "isSignal": true; }; "divider": { "alias": "divider"; "required": false; "isSignal": true; }; "tabularValues": { "alias": "tabularValues"; "required": false; "isSignal": true; }; "termWidth": { "alias": "termWidth"; "required": false; "isSignal": true; }; }, { "valueClicked": "valueClicked"; }, never, never, true, never>;
+}
+
+/** Motor de captcha. `turnstile` es privacy-friendly (recomendado). */
+type IusCaptchaProvider = 'turnstile' | 'recaptcha' | 'hcaptcha';
+/** Tema del widget (passthrough al proveedor). */
+type IusCaptchaTheme = 'auto' | 'light' | 'dark';
+/** Tamaño/disposición — vocabulario del proveedor, NO la escala del DS. */
+type IusCaptchaSize = 'normal' | 'flexible' | 'compact';
+/** Modo de aparición (Turnstile). */
+type IusCaptchaAppearance = 'always' | 'execute' | 'interaction-only';
+/** Estado forzado — SOLO demos / especímenes del DS. */
+type IusCaptchaState = 'loading' | 'ready' | 'verified' | 'expired' | 'error' | 'disabled';
+/** Contrato imperativo del campo (equivale al `CaptchaFieldHandle` del golden). */
+interface IusCaptchaFieldHandle {
+    reset(): void;
+    execute(): void;
+    getResponse(): string;
+    getWidgetId(): string | number | null;
+}
+/** Opciones normalizadas que el adaptador pasa al `render` del proveedor. */
+interface RenderOptions {
+    sitekey: string;
+    theme: IusCaptchaTheme;
+    size: IusCaptchaSize;
+    appearance: IusCaptchaAppearance;
+    language: string;
+    action?: string;
+    cData?: string;
+    onVerify: (token: string) => void;
+    onExpire: () => void;
+    onError: (code?: string) => void;
+    onTimeout: () => void;
+}
+/** Adaptador por proveedor — normaliza render/reset/remove/execute. */
+interface ProviderAdapter {
+    scriptUrl: string;
+    global: string;
+    responseField: string;
+    label: string;
+    render(el: HTMLElement, o: RenderOptions): string | number;
+    reset(id: string | number): void;
+    remove(id: string | number): void;
+    execute(id: string | number): void;
+}
+interface PlaceholderContent {
+    icon: string;
+    name: string;
+    note: string;
+}
+/**
+ * CaptchaField — Ius Design v2.
+ *
+ * Campo de formulario que **integra un reto captcha de terceros** (Cloudflare
+ * Turnstile por defecto · Google reCAPTCHA · hCaptcha) en el lenguaje del
+ * sistema. El reto visual lo dibuja el proveedor dentro de un iframe que **no
+ * se puede reestilizar**; el DS posee el marco: hueco reservado, esqueleto de
+ * carga, label/ayuda, error de validación y el token oculto para el envío del
+ * formulario. Fuente de verdad: `CaptchaField.jsx` + `CaptchaField.d.ts` +
+ * `CaptchaField.ng-spec.md`.
+ *
+ * Implementa `ControlValueAccessor`: el valor de control es el **token** del
+ * reto. Se emite en `onVerify` (nuevo token) y se limpia a `''` en
+ * `onExpire`/`reset`. El script del proveedor se carga una sola vez por URL.
+ *
+ * `Skeleton` aún no está portado: el estado de carga usa un esqueleto inline
+ * con tokens `--ius-*` (mismo alto que el hueco, sin salto de layout).
+ * Reemplazar por `<ius-skeleton>` cuando exista.
+ */
+declare class CaptchaFieldComponent implements ControlValueAccessor, IusCaptchaFieldHandle {
+    private readonly platformId;
+    private readonly providerState;
+    set provider(value: IusCaptchaProvider);
+    get provider(): IusCaptchaProvider;
+    private readonly sitekeyState;
+    /** Clave pública del sitio. Sin ella se muestra el hueco reservado (docs). */
+    set sitekey(value: string | undefined);
+    get sitekey(): string | undefined;
+    private readonly themeState;
+    set theme(value: IusCaptchaTheme);
+    get theme(): IusCaptchaTheme;
+    protected readonly sizeState: _angular_core.WritableSignal<IusCaptchaSize>;
+    set size(value: IusCaptchaSize);
+    get size(): IusCaptchaSize;
+    private readonly appearanceState;
+    set appearance(value: IusCaptchaAppearance);
+    get appearance(): IusCaptchaAppearance;
+    private readonly languageState;
+    set language(value: string);
+    get language(): string;
+    private readonly actionState;
+    /** Parámetro `action` (Turnstile) para telemetría del reto. */
+    set action(value: string | undefined);
+    get action(): string | undefined;
+    private readonly cDataState;
+    /** Datos de cliente opacos (`cData` de Turnstile). */
+    set cData(value: string | undefined);
+    get cData(): string | undefined;
+    private readonly disabledState;
+    /** Deshabilitado: no monta el reto; muestra el hueco inerte. */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    private readonly errorState;
+    /** Estado de error de validación (tiñe el marco `danger` + `errorText`). */
+    set error(value: boolean);
+    get error(): boolean;
+    /**
+     * Forzar visualmente un estado — **solo demos / especímenes del DS**. Salta
+     * el montaje real y pinta el hueco reservado en ese estado. No usar en
+     * producción (el reto real dibuja sus propios estados dentro del iframe).
+     */
+    protected readonly stateState: _angular_core.WritableSignal<IusCaptchaState | undefined>;
+    set state(value: IusCaptchaState | undefined);
+    get state(): IusCaptchaState | undefined;
+    /** Label sobre el hueco. */
+    label?: string;
+    /** Texto de ayuda bajo el hueco. */
+    helpText?: string;
+    /** Reemplaza `helpText` cuando `error` es `true`. */
+    errorText?: string;
+    /** Nombre del input oculto que lleva el token (default por proveedor). */
+    responseFieldName?: string;
+    /** `id` del hueco/`<label>` (auto-generado si se omite). */
+    id?: string;
+    /** Reto resuelto → token a validar en el backend. */
+    readonly verify: EventEmitter<string>;
+    /** Token expirado. */
+    readonly expire: EventEmitter<void>;
+    /** Fallo del reto (código del proveedor). */
+    readonly errored: EventEmitter<string | undefined>;
+    /** Reto interactivo agotado. */
+    readonly timedOut: EventEmitter<void>;
+    /** Token (además del CVA). */
+    readonly valueChange: EventEmitter<string>;
+    protected readonly token: _angular_core.WritableSignal<string>;
+    /** 'loading' | 'ready' | 'error' — fase del montaje del widget real. */
+    protected readonly phase: _angular_core.WritableSignal<"error" | "loading" | "ready">;
+    private widgetId;
+    private readonly baseId;
+    private readonly hostRef;
+    private onChange;
+    private onTouched;
+    protected readonly adapter: _angular_core.Signal<ProviderAdapter>;
+    protected readonly isDemo: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    /** ¿Montar el widget real? Solo con sitekey, sin demo y habilitado. */
+    protected readonly useLive: _angular_core.Signal<boolean>;
+    protected readonly ph: _angular_core.Signal<PlaceholderContent>;
+    protected get fieldId(): string;
+    protected get respName(): string;
+    protected get hint(): string | undefined;
+    constructor();
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Reinicia el reto (p. ej. tras un login fallido). */
+    reset(): void;
+    /** Ejecuta el reto manualmente (`appearance="execute"` / modo invisible). */
+    execute(): void;
+    /** Token actual del proveedor (cadena vacía si aún no hay). */
+    getResponse(): string;
+    /** Id interno del widget del proveedor (o `null`). */
+    getWidgetId(): string | number | null;
+    private handleVerify;
+    private handleExpire;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CaptchaFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CaptchaFieldComponent, "ius-captcha-field", never, { "provider": { "alias": "provider"; "required": false; }; "sitekey": { "alias": "sitekey"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "size": { "alias": "size"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "language": { "alias": "language"; "required": false; }; "action": { "alias": "action"; "required": false; }; "cData": { "alias": "cData"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "error": { "alias": "error"; "required": false; }; "state": { "alias": "state"; "required": false; }; "label": { "alias": "label"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "responseFieldName": { "alias": "responseFieldName"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "verify": "verify"; "expire": "expire"; "errored": "errored"; "timedOut": "timedOut"; "valueChange": "valueChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_error: unknown;
+}
+
+/** Propósito semántico — fija defaults sin bloquear capacidades. */
+type IusTagRole = 'label' | 'status' | 'filter';
+/** Familia de color: 6 semánticas + 6 frutas categóricas. */
+type IusTagTone = 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'neutral' | 'durazno' | 'banano' | 'sandia' | 'arandano' | 'uva' | 'aguacate';
+/** Tratamiento de color. */
+type IusTagVariant = 'soft' | 'outline' | 'solid';
+/** Tamaño. */
+type IusTagSize = 'small' | 'medium' | 'large';
+/** Forma. */
+type IusTagShape = 'pill' | 'rounded';
+/** Estado forzado — solo demos. */
+type IusTagState = 'idle' | 'hover' | 'pressed' | 'focused';
+/**
+ * Marca un prefijo libre proyectado (anula `icon`/`dot`):
+ * `<ius-tag><span iusTagPrefix>…</span>Texto</ius-tag>`.
+ */
+declare class IusTagPrefixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IusTagPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IusTagPrefixDirective, "[iusTagPrefix]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marca un sufijo libre proyectado (se ignora si hay `count`):
+ * `<ius-tag>Texto<span iusTagSuffix>…</span></ius-tag>`.
+ */
+declare class IusTagSuffixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IusTagSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IusTagSuffixDirective, "[iusTagSuffix]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Tag — Ius Design v2 (familia data-display).
+ *
+ * Etiqueta compacta con prefijo/sufijo para clasificar, filtrar o marcar estado.
+ * No intrusiva con el color: `soft` (tinte suave, default) · `outline` (solo el
+ * acento coloreado) · `solid` (relleno fuerte, reservado a seleccionado/activo).
+ * 12 tonos (6 semánticos + 6 frutas), 3 tamaños, `pill`/`rounded`, icon/dot/
+ * prefix, count (`· N`)/suffix y cierre (×). Fuente de verdad: `Tag.jsx` +
+ * `Tag.d.ts` + `Tag.ng-spec.md`.
+ *
+ * `role`: `label` (soft, estático) · `status` (soft + dot) · `filter`
+ * (outline → solid al `selected`; interactivo). Un Tag interactivo (filter o
+ * `[interactive]`) se comporta como botón (patrón ARIA `role="button"` sobre el
+ * host: focusable, Enter/Espacio, `aria-pressed`) y emite `clicked`; el `×` emite
+ * `closed`. Se usa host = pill (no se cambia el tag entre span/button) para no
+ * duplicar los `<ng-content>` de proyección.
+ *
+ * Para tokens removibles en un campo → Chip; indicador atómico → Insignia.
+ * En contexto Alert `solid`, la armonización on-color la aporta el CSS del Alert.
+ */
+declare class TagComponent {
+    private readonly el;
+    /** Texto de la etiqueta (alternativa a proyectar contenido). */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Propósito semántico (fija defaults de variant/dot). */
+    readonly role: _angular_core.InputSignal<IusTagRole>;
+    /** Familia de color. */
+    readonly tone: _angular_core.InputSignal<IusTagTone>;
+    /** Tratamiento de color; si se omite lo fija el `role`. */
+    readonly variant: _angular_core.InputSignal<IusTagVariant | undefined>;
+    /** Tamaño. */
+    readonly size: _angular_core.InputSignal<IusTagSize>;
+    /** Forma. */
+    readonly shape: _angular_core.InputSignal<IusTagShape>;
+    /** Ícono Material Symbols como prefijo (toma el acento). */
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    /** Punto de acento como prefijo; si se omite lo fija el `role`. */
+    readonly dot: _angular_core.InputSignal<boolean | undefined>;
+    /** Sufijo numérico → `· N`. */
+    readonly count: _angular_core.InputSignal<string | number | undefined>;
+    /** Muestra el botón de cierre (×). */
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** aria-label del cierre. */
+    readonly closeLabel: _angular_core.InputSignal<string>;
+    /** Seleccionado (fuerza `solid`); úsalo con filtros. */
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Deshabilitado. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marca el Tag como interactivo (botón). `role="filter"` ya lo implica. */
+    readonly interactive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Forzar visualmente un estado (demos). */
+    readonly state: _angular_core.InputSignal<IusTagState | undefined>;
+    /** Filtro pulsado (original `onClick`). */
+    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** Cierre pulsado (original `onClose`). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly prefixRef;
+    private readonly suffixRef;
+    protected readonly hasPrefix: _angular_core.Signal<boolean>;
+    protected readonly hasSuffix: _angular_core.Signal<boolean>;
+    /** Interactivo si se marca explícito o el rol es `filter`. */
+    protected readonly isInteractive: _angular_core.Signal<boolean>;
+    private readonly baseVariant;
+    /** Variante efectiva: `selected` fuerza `solid`. */
+    protected readonly effVariant: _angular_core.Signal<IusTagVariant>;
+    /** Mostrar dot: valor explícito o el default del rol. */
+    protected readonly showDot: _angular_core.Signal<boolean>;
+    protected onClickHost(event: MouseEvent): void;
+    /**
+     * Activa el Tag interactivo disparando un click nativo del host. Se enlaza a
+     * Enter en `keydown` y a Espacio en `keyup` (patrón WAI-ARIA button: igual que
+     * un `<button>` nativo, Enter repite al mantenerse y Espacio activa una sola
+     * vez al soltar).
+     */
+    protected onKeyActivate(event: Event): void;
+    /** Espacio en `keydown`: solo evita el scroll; la activación ocurre en `keyup`. */
+    protected onSpaceDown(event: Event): void;
+    protected onClose(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "ius-tag", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; "closed": "closed"; }, ["prefixRef", "suffixRef"], ["[iusTagPrefix]", "*", "[iusTagSuffix]"], true, never>;
+}
+
+/** Tamaño del campo: small ~34 · medium ~40 (default) · large ~48 px. */
+type IusMultiTextFieldSize = 'small' | 'medium' | 'large';
+/** Estado forzado — solo demos / especímenes. */
+type IusMultiTextFieldState = 'hover' | 'focused' | 'error' | 'disabled';
+/** Un segmento (`<input>`) del MultiTextField. */
+interface IusMultiTextFieldSlot {
+    /** Placeholder del segmento. */
+    placeholder?: string;
+    /** `name` del input (envío como form). */
+    name?: string;
+    /** Tipo del `<input>`. Default `text`. */
+    type?: 'text' | 'number' | 'tel' | 'password';
+    /** Valor controlado del segmento. */
+    value?: string;
+    /** Valor inicial (no controlado). */
+    defaultValue?: string;
+    /** Ancho fijo. Número → px; string → CSS literal. */
+    width?: number | string;
+    /** `flex` (`'1 1 auto'`, `'0 0 60px'`, …) si necesitas más control que `width`. */
+    flex?: string | number;
+    /** Largo máximo de caracteres (habilita auto-avance). */
+    maxLength?: number;
+    /** Etiqueta accesible del segmento (si el placeholder no basta). */
+    ariaLabel?: string;
+    /** Callback opcional al teclear este segmento (además del `valueChange` del conjunto). */
+    onChange?: (value: string, event: Event) => void;
+}
+/**
+ * MultiTextField — Ius Design v2 (familia inputs).
+ *
+ * Variación de **TextField** que acopla varios `<input>` dentro de una misma
+ * caja separados por divisores verticales — para datos compuestos (tarjeta
+ * MM | AAAA + CVV, teléfono con prefijo, NIT + DV…). Reusa el wrapper `.ius-tf`
+ * (label con required + iconHelp, 5 estados, size, helpText/errorText) y un
+ * **único** botón de limpiar que vacía todos los segmentos. Fuente de verdad:
+ * `MultiTextField.jsx` + `MultiTextField.d.ts` (delta sobre `TextField.ng-spec`).
+ *
+ * `ControlValueAccessor` **a nivel de conjunto**: el valor es el array de
+ * valores por segmento (`string[]`); también se emite en `valueChange`. Cada
+ * slot puede además traer su propio `onChange`. Auto-avance al llenar el
+ * `maxLength` y Backspace en segmento vacío retrocede.
+ *
+ * Nota: las clases `.ius-tf__*` (label/help/hint/field/clear) se replican en el
+ * SCSS porque bajo `ViewEncapsulation.Emulated` las de TextField no alcanzan a
+ * otro componente. `showIconHelp` usa `title` nativo como respaldo hasta que
+ * exista `ius-popover`. `[data-force]` congela un estado visual en demos.
+ */
+declare class MultiTextFieldComponent implements ControlValueAccessor {
+    protected readonly slotsState: _angular_core.WritableSignal<IusMultiTextFieldSlot[]>;
+    /** Segmentos; cada uno un `<input>` separado por un divisor vertical. */
+    set slots(value: IusMultiTextFieldSlot[]);
+    get slots(): IusMultiTextFieldSlot[];
+    /** Label común a todos los segmentos. */
+    label?: string;
+    /** Indicador de obligatorio (•). */
+    required: boolean;
+    /** Ícono de ayuda `?` junto al label (respaldo: `title` nativo). */
+    showIconHelp: boolean;
+    /** Título del contenido de ayuda. */
+    iconHelpTitle?: string;
+    /** Cuerpo del contenido de ayuda. */
+    iconHelpContent?: string;
+    /** Línea de ayuda bajo el campo. */
+    helpText?: string;
+    /** Reemplaza `helpText` cuando `error` es `true`. */
+    errorText?: string;
+    /** Mostrar/ocultar la línea de ayuda. */
+    showHelpText: boolean;
+    /** Forzar visibilidad del botón limpiar (por defecto: auto con valor). */
+    showClear?: boolean;
+    private readonly errorState;
+    /** Estado de error global. */
+    set error(value: boolean);
+    get error(): boolean;
+    private readonly disabledState;
+    /** Estado deshabilitado global. */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    protected readonly sizeState: _angular_core.WritableSignal<IusMultiTextFieldSize>;
+    set size(value: IusMultiTextFieldSize);
+    get size(): IusMultiTextFieldSize;
+    protected readonly stateState: _angular_core.WritableSignal<IusMultiTextFieldState | undefined>;
+    /** Forzar visualmente un estado completo (solo demos). */
+    set state(value: IusMultiTextFieldState | undefined);
+    get state(): IusMultiTextFieldState | undefined;
+    /** `id` base del campo (los segmentos serán `id-0`, `id-1`, …). */
+    id?: string;
+    /** Valores del conjunto (array por segmento). */
+    readonly valueChange: EventEmitter<string[]>;
+    /** Al pulsar el botón de limpiar (después de vaciar). */
+    readonly cleared: EventEmitter<void>;
+    protected readonly values: _angular_core.WritableSignal<string[]>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    /** Tras limpiar en un estado demo, suprime el "valor" simulado. */
+    private readonly suppressDemoValue;
+    /** Último valor escrito por el CVA (por si llega antes que los slots). */
+    private readonly pendingValue;
+    private readonly baseIdState;
+    private readonly slotInputs;
+    private onChange;
+    private onTouched;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly isFocused: _angular_core.Signal<boolean>;
+    protected readonly hasAnyValue: _angular_core.Signal<boolean>;
+    protected readonly demoHasValue: _angular_core.Signal<boolean>;
+    protected get baseId(): string;
+    protected get helpId(): string;
+    protected get hint(): string | undefined;
+    protected get showHint(): boolean;
+    protected get helpIconTitle(): string | undefined;
+    /** El botón de limpiar está activo (visible y operable). */
+    protected get clearActive(): boolean;
+    /** Se reserva el hueco del clear (visibility) para no desplazar los segmentos. */
+    protected get clearReserved(): boolean;
+    protected currentValue(i: number): string;
+    /** flex del segmento: width > flex > (maxLength → base auto) > CSS (1 1 auto). */
+    protected slotFlex(slot: IusMultiTextFieldSlot): string | null;
+    /** width del segmento: solo cuando se deriva del maxLength. */
+    protected slotWidth(slot: IusMultiTextFieldSlot): string | null;
+    writeValue(value: string[] | null): void;
+    registerOnChange(fn: (value: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private syncValues;
+    private commit;
+    private focusSlot;
+    protected onSlotInput(i: number, event: Event): void;
+    protected onSlotKeyDown(i: number, event: KeyboardEvent): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiTextFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiTextFieldComponent, "ius-multi-text-field", never, { "slots": { "alias": "slots"; "required": false; }; "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showIconHelp": { "alias": "showIconHelp"; "required": false; }; "iconHelpTitle": { "alias": "iconHelpTitle"; "required": false; }; "iconHelpContent": { "alias": "iconHelpContent"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "showHelpText": { "alias": "showHelpText"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "error": { "alias": "error"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "state": { "alias": "state"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "valueChange": "valueChange"; "cleared": "cleared"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_showIconHelp: unknown;
+    static ngAcceptInputType_showHelpText: unknown;
+    static ngAcceptInputType_error: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Ancho máximo del diálogo — small 380 · medium 520 (default) · large 680px. */
+type IusModalSize = 'small' | 'medium' | 'large';
+/** Tono del círculo del ícono del header. */
+type IusModalIconTone = 'info' | 'success' | 'warning' | 'danger' | 'primary' | 'neutral';
+/** Motivo del cierre emitido por `closed`. */
+type IusModalCloseReason = 'close' | 'esc' | 'scrim' | 'secondary';
+/**
+ * Marca el footer libre proyectado. Tiene prioridad sobre el footer de
+ * conveniencia (`primaryLabel`/`secondaryLabel`):
+ *
+ * ```html
+ * <ius-modal ...>
+ *   …cuerpo…
+ *   <div iusModalFooter>…acciones a medida…</div>
+ * </ius-modal>
+ * ```
+ */
+declare class IusModalFooterDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IusModalFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IusModalFooterDirective, "[iusModalFooter]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Modal — Ius Design v2.
+ *
+ * Diálogo centrado sobre un scrim que exige atención/decisión (confirmaciones,
+ * avisos accionables) sin abandonar la pantalla. Se monta vía **CDK Overlay** en
+ * `document.body` (no acepta `container`): portal + **scroll-lock** del fondo +
+ * **focus-trap** dentro (`cdkTrapFocus`). `Esc`/scrim cierran (configurable).
+ * `role="dialog"` `aria-modal="true"`.
+ *
+ * Compone `ius-button` (footer) e `ius-icon-button` (cerrar) — no introduce
+ * controles propios. Para tareas con varios campos usar Drawer; para avisos no
+ * bloqueantes usar Alert/Toast.
+ *
+ */
+declare class ModalComponent implements AfterViewInit, OnDestroy {
+    private readonly overlay;
+    private readonly viewContainerRef;
+    /** Template con scrim + diálogo; se portalea al overlay al abrir. */
+    private tpl;
+    /** Footer libre proyectado (`[iusModalFooter]`). Si existe, gana al de conveniencia. */
+    protected customFooter?: IusModalFooterDirective;
+    private _open;
+    /** Apertura controlada. */
+    set open(value: boolean);
+    get open(): boolean;
+    /** Ancho máximo (380·520·680; ≤480px full-width). */
+    size: IusModalSize;
+    /** Título del header. */
+    title?: string;
+    /** Descripción breve bajo el título. */
+    description?: string;
+    /** Ligadura Material Symbols al inicio del header (círculo suave del tono). */
+    icon?: string;
+    /** Tono del círculo del ícono. */
+    iconTone: IusModalIconTone;
+    /** Botón de cerrar (×) en el header. */
+    showClose: boolean;
+    /** Texto del botón primario de conveniencia. */
+    primaryLabel?: string;
+    /** Loading del primario. */
+    primaryLoading: boolean;
+    /** Deshabilita el primario. */
+    primaryDisabled: boolean;
+    /** Acción destructiva: el primario de conveniencia usa `variant="danger"` (rojo). */
+    destructive: boolean;
+    /** Texto del botón secundario. `null` lo oculta. */
+    secondaryLabel: string | null;
+    /** Divisores entre header/body/footer. */
+    dividers: boolean;
+    /** Cerrar al hacer clic en el scrim. */
+    closeOnScrim: boolean;
+    /** Cerrar con Escape. */
+    closeOnEsc: boolean;
+    /** z-index del scrim. */
+    zIndex: number;
+    /** Etiqueta accesible si no hay `title`. */
+    ariaLabel?: string;
+    /** Cierre con el motivo (`onClose` del golden). */
+    readonly closed: EventEmitter<IusModalCloseReason>;
+    /** Clic en el primario de conveniencia (`onPrimary`). */
+    readonly primary: EventEmitter<MouseEvent>;
+    /** Clic en el secundario de conveniencia (`onSecondary`). Si nadie lo escucha, cierra. */
+    readonly secondary: EventEmitter<void>;
+    private overlayRef;
+    private keydownSub;
+    private viewReady;
+    protected get hasHead(): boolean;
+    protected get iconColors(): {
+        bg: string;
+        fg: string;
+    };
+    protected get showSecondary(): boolean;
+    /** Footer de conveniencia sólo si no hay footer libre y hay algo que mostrar. */
+    protected get hasConvenienceFooter(): boolean;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private sync;
+    private attach;
+    private detach;
+    protected onScrimMouseDown(event: MouseEvent): void;
+    protected onCloseClick(): void;
+    protected onPrimary(event: MouseEvent): void;
+    protected onSecondary(): void;
+    private emitClose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "ius-modal", never, { "open": { "alias": "open"; "required": false; }; "size": { "alias": "size"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconTone": { "alias": "iconTone"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "primaryLabel": { "alias": "primaryLabel"; "required": false; }; "primaryLoading": { "alias": "primaryLoading"; "required": false; }; "primaryDisabled": { "alias": "primaryDisabled"; "required": false; }; "destructive": { "alias": "destructive"; "required": false; }; "secondaryLabel": { "alias": "secondaryLabel"; "required": false; }; "dividers": { "alias": "dividers"; "required": false; }; "closeOnScrim": { "alias": "closeOnScrim"; "required": false; }; "closeOnEsc": { "alias": "closeOnEsc"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "closed": "closed"; "primary": "primary"; "secondary": "secondary"; }, ["customFooter"], ["*", "[iusModalFooter]"], true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_showClose: unknown;
+    static ngAcceptInputType_primaryLoading: unknown;
+    static ngAcceptInputType_primaryDisabled: unknown;
+    static ngAcceptInputType_destructive: unknown;
+    static ngAcceptInputType_dividers: unknown;
+    static ngAcceptInputType_closeOnScrim: unknown;
+    static ngAcceptInputType_closeOnEsc: unknown;
+    static ngAcceptInputType_zIndex: unknown;
+}
+
+/**
+ * Rol tipográfico → clase de escala (`typography.css`). `body` es alias de
+ * `body-base`. Mapa exacto en VARIANT_CLASS/DEFAULT_TAG.
+ */
+type IusTextVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'body-lg' | 'emphasis-lg' | 'body-base' | 'emphasis-base' | 'body' | 'caption' | 'body-sm' | 'label' | 'overline';
+/**
+ * Alias de color de texto → `--ius-text-*`. `danger`→`--ius-text-error`,
+ * `inverse`→`--ius-text-on-primary`.
+ */
+type IusTextColor = 'primary' | 'secondary' | 'tertiary' | 'disabled' | 'inverse' | 'success' | 'danger' | 'warning' | 'info' | 'link';
+type IusTextWeight = 'regular' | 'medium' | 'bold';
+type IusTextAlign = 'left' | 'center' | 'right' | 'justify';
+/**
+ * Tag polimórfico soportado. Adaptación Angular del `as` (React acepta cualquier
+ * `keyof JSX.IntrinsicElements`; aquí un set finito para elegir el template, tal
+ * como recomienda la ng-spec §3). Cubre los tags del sistema + inline comunes.
+ */
+type IusTextTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'p' | 'span' | 'label' | 'div' | 'strong' | 'em' | 'small';
+/**
+ * Text — Ius Design v2. Primitiva tipográfica (display-only, sin estado).
+ *
+ * Wrapper delgado sobre la escala de `typography.css`: mapea `variant` → clase y
+ * expone `color / weight / as / align / italic / truncate / tabularNums` con
+ * tokens `--ius-*` (cero valores crudos). Contrato único para todo texto plano.
+ *
+ * El host `ius-text` usa `display: contents`, así que no genera caja propia: el
+ * tag renderizado (h1…h5 / p / span / label…) se comporta como hijo directo.
+ *
+ * Port completo: los 14 variants mapean a su clase real de `typography.css`
+ * (incl. `.ius-label`/`.ius-overline`) y los 10 colores a su token `--ius-text-*`
+ * (incl. `--ius-text-warning`/`--ius-text-info`), sincronizados desde Claude Design.
+ *
+ * Fuente de verdad: `components/data-display/Text/Text.jsx` + `Text.d.ts`
+ * (contrato en `Text.ng-spec.md` §4).
+ */
+declare class TextComponent {
+    /** Rol tipográfico → clase de escala + tag por defecto. */
+    variant: IusTextVariant;
+    /** Color semántico (alias → `--ius-text-*`). Sin valor: hereda el de la clase. */
+    color?: IusTextColor;
+    /** Peso: override del peso por defecto del variant → `--ius-fw-*`. */
+    weight?: IusTextWeight;
+    /** Tag polimórfico: override del tag semántico por defecto del variant. */
+    as?: IusTextTag;
+    /** Alineación (`text-align`). */
+    align?: IusTextAlign;
+    /** Itálico (clase modificadora en body-base/caption/body-sm; inline en el resto). */
+    italic: boolean;
+    /** Trunca a una línea con elipsis. */
+    truncate: boolean;
+    /** Números tabulares (montos/radicados es-CO). */
+    tabularNums: boolean;
+    /** `for` del `<label>` (sólo aplica cuando el tag renderizado es `label`). */
+    for?: string;
+    /** Tag efectivo (as > default del variant > span). */
+    protected get tag(): IusTextTag;
+    private get variantClass();
+    /** `ius-text` base + clase de escala (+ modificador itálico si aplica). */
+    protected get klass(): string;
+    /** Overrides por token (color/weight/align/italic-inline/tabular/truncate). */
+    protected get styleObject(): Record<string, string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextComponent, "ius-text", never, { "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "weight": { "alias": "weight"; "required": false; }; "as": { "alias": "as"; "required": false; }; "align": { "alias": "align"; "required": false; }; "italic": { "alias": "italic"; "required": false; }; "truncate": { "alias": "truncate"; "required": false; }; "tabularNums": { "alias": "tabularNums"; "required": false; }; "for": { "alias": "for"; "required": false; }; }, {}, never, ["*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*"], true, never>;
+    static ngAcceptInputType_italic: unknown;
+    static ngAcceptInputType_truncate: unknown;
+    static ngAcceptInputType_tabularNums: unknown;
+}
+
+/** Degradado base según el fondo. */
+type IusLoadingMarkSurface = 'light' | 'dark';
+/**
+ *
+ * Cargador de **identidad** Litigiovirtual: tres fichas se deslizan por el
+ * cuadrado mientras el conjunto gira y un **cometa** de luz cian orbita el
+ * contorno sobre el degradado base navy→cian. Para splash, arranque y esperas
+ * largas donde la marca debe estar presente. Para una espera neutra/compacta
+ * dentro de la UI botón, fila, panel, usar Loading/CircularProgress; este no
+ * lleva etiqueta ni se incrusta en controles.
+ *
+ */
+declare class LoadingMarkComponent {
+    /** Lado del cuadro en px. */
+    size: number;
+    /** `light` navy sólido (default) · `dark` navy→cian sobre superficie navy. */
+    surface: IusLoadingMarkSurface;
+    /** Congela la animación (figura estática). También respeta reduced-motion. */
+    paused: boolean;
+    /** Etiqueta accesible. */
+    ariaLabel: string;
+    private readonly id;
+    protected readonly baseId: string;
+    protected readonly glowId: string;
+    protected readonly softId: string;
+    protected readonly maskId: string;
+    /** Parada inicial del degradado base (siempre navy). */
+    protected get baseFrom(): string;
+    /** Parada final: navy en `light`; abre a `--ius-primary-600` en `dark`. */
+    protected get baseTo(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingMarkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoadingMarkComponent, "ius-loading-mark", never, { "size": { "alias": "size"; "required": false; }; "surface": { "alias": "surface"; "required": false; }; "paused": { "alias": "paused"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_size: unknown;
+    static ngAcceptInputType_paused: unknown;
+}
+
+/** Escala del sistema — small ~34 · medium ~40 (default) · large ~48px. */
+type IusSegmentedSize = 'small' | 'medium' | 'large';
+/** `subtle` = pastilla blanca elevada (default) · `solid` = pastilla navy de marca. */
+type IusSegmentedVariant = 'subtle' | 'solid';
+/** Opción del control (2–5, cortas, todas visibles). */
+interface SegmentedOption {
+    /** Valor único (lo que recibe `valueChange`). */
+    value: string;
+    /** Etiqueta visible (omitible en `iconOnly`). */
+    label?: string;
+    /** Ligadura Material Symbols Rounded. */
+    icon?: string;
+    /** Etiqueta accesible cuando `iconOnly` oculta el texto. */
+    ariaLabel?: string;
+    title?: string;
+    /** Deshabilita sólo esta opción. */
+    disabled?: boolean;
+}
+/**
+ * SegmentedControl — Ius Design v2.
+ *
+ * Selector **único** de pocas opciones cortas, mutuamente excluyentes y **todas
+ * visibles a la vez** (Mes/Semana/Día, filtros de estado, conmutadores de modo).
+ * Para 0–1 opción → Switch; para muchas/largas → Select; para acciones → Button.
+ *
+ * `role="radiogroup"` + `role="radio"` con `aria-checked`; navegación con
+ * ←/→/↑/↓/Home/End (mueve foco y selección) y roving `tabindex`. Implementa
+ * `ControlValueAccessor` (`string`) y además soporta `[(value)]` directo.
+ *
+ * Fuente de verdad: `components/inputs/SegmentedControl/SegmentedControl.jsx` + `.d.ts`.
+ */
+declare class SegmentedControlComponent implements ControlValueAccessor {
+    /** Opciones mutuamente excluyentes (2–5 cortas; todas visibles). */
+    options: SegmentedOption[];
+    /** Escala del sistema. */
+    size: IusSegmentedSize;
+    /** Jerarquía visual de la pastilla seleccionada. */
+    variant: IusSegmentedVariant;
+    /** Ocupa todo el ancho, repartiendo las opciones por igual. */
+    fullWidth: boolean;
+    /** Sólo íconos (oculta labels; usa ariaLabel/label como título accesible). */
+    iconOnly: boolean;
+    /** Etiqueta accesible del grupo. */
+    ariaLabel?: string;
+    /** `name` de los radios. */
+    name?: string;
+    private readonly valueState;
+    /** Valor seleccionado (controlado / CVA). */
+    set value(v: string | undefined);
+    get value(): string | undefined;
+    private readonly disabledState;
+    /** Deshabilita todo el control. */
+    set disabled(v: boolean);
+    get disabled(): boolean;
+    /** Cambio de selección (original `onChange`). Habilita `[(value)]`. */
+    readonly valueChange: EventEmitter<string>;
+    protected readonly selected: _angular_core.Signal<string | undefined>;
+    private readonly optRefs;
+    private onChange;
+    private onTouched;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected isEnabled(o: SegmentedOption): boolean;
+    /** Roving tabindex (espejo del golden: seleccionado, o el primero si no hay valor). */
+    protected tabIndexFor(o: SegmentedOption, index: number): number;
+    private commit;
+    private focusAndSelect;
+    private focusByOffset;
+    protected onOptionClick(o: SegmentedOption): void;
+    protected onKeyDown(event: KeyboardEvent, index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlComponent, "ius-segmented-control", never, { "options": { "alias": "options"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ngAcceptInputType_fullWidth: unknown;
+    static ngAcceptInputType_iconOnly: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Escala del campo — small ~34 · medium ~40 (default) · large ~48px. */
+type IusSelectSize = 'small' | 'medium' | 'large';
+/** Estado forzado — **solo demos/especímenes**. En producción usar `disabled`/`error`. */
+type IusSelectState = 'hover' | 'focused' | 'open' | 'error' | 'disabled';
+/** Valor escalar de una opción. */
+type IusSelectValue = string | number;
+/** Opción del desplegable (plana). */
+interface SelectOption {
+    /** Valor único (lo que recibe `valueChange`). */
+    value: IusSelectValue;
+    /** Etiqueta visible. */
+    label: string;
+    /** Ícono Material Symbols Rounded a la izquierda de la opción. */
+    icon?: string;
+    /** Opción no seleccionable. */
+    disabled?: boolean;
+}
+/** Grupo de opciones (encabezado de sección + opciones). */
+interface SelectOptionGroup {
+    /** Encabezado de sección. */
+    label: string;
+    options: SelectOption[];
+}
+interface VisibleGroup {
+    label: string | null;
+    items: {
+        opt: SelectOption;
+        flatIndex: number;
+    }[];
+}
+interface VisibleModel {
+    groups: VisibleGroup[];
+    flat: SelectOption[];
+}
+/**
+ * Select — Ius Design v2.
+ *
+ * Campo desplegable que reúne el shell del **TextField** (label + required +
+ * iconHelp + prefixIcon + sufix chevron + estados + helpText/errorText, `size`)
+ * y abre un menú con **scroll**, **búsqueda en vivo** (caja dentro del menú) y
+ * **selección única o múltiple**. Implementa `ControlValueAccessor` completo
+ * (valor escalar en single / array en múltiple) y además soporta `[(value)]`.
+ *
+ * - Single: muestra la etiqueta elegida; la opción se resalta en azul (fill).
+ * - Múltiple: chips removibles dentro del campo + check por opción elegida.
+ *
+ * Fuente de verdad: `components/inputs/Select/Select.jsx` + `.d.ts` + ng-spec.
+ *
+ * Notas del port a Angular:
+ * - El shell `.ius-tf` del TextField está *scoped* (`:host`) en su componente,
+ *   así que su CSS se re-porta aquí (mismo patrón que el resto del monorepo).
+ * - El golden compone `OptionItem` (filas) y `Chip` (chips de múltiple): ya
+ *   portados como `ius-option-item` / `ius-chip`, se componen aquí directamente
+ *   (sin CSS inlineado). Los chips de múltiple usan `ius-chip removable`.
+ * - El menú se posiciona con `position: fixed` + medición manual (flip abajo/
+ *   arriba, iguala ancho del campo), espejo de `updatePosition` del golden.
+ */
+declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    private readonly optionsState;
+    /** Opciones planas o agrupadas por secciones. */
+    set options(value: SelectOption[] | SelectOptionGroup[]);
+    get options(): SelectOption[] | SelectOptionGroup[];
+    private readonly multipleState;
+    /** Permitir elegir varias opciones (chips + checks). */
+    set multiple(value: boolean);
+    get multiple(): boolean;
+    private readonly sizeState;
+    /** Escala del campo. */
+    set size(value: IusSelectSize);
+    get size(): IusSelectSize;
+    private readonly disabledState;
+    /** Estado deshabilitado. */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    private readonly errorState;
+    /** Estado de error (borde rojo + errorText). */
+    set error(value: boolean);
+    get error(): boolean;
+    /** Estado forzado — **solo demos/especímenes** del DS. */
+    protected readonly stateInput: _angular_core.WritableSignal<IusSelectState | undefined>;
+    set state(value: IusSelectState | undefined);
+    get state(): IusSelectState | undefined;
+    private readonly openInput;
+    private openControlled;
+    /** Apertura controlada del menú. */
+    set open(value: boolean);
+    get open(): boolean;
+    private readonly valueState;
+    private hasExplicitValue;
+    /** Valor controlado: escalar en single, array en múltiple (CVA / `[(value)]`). */
+    set value(value: IusSelectValue | IusSelectValue[] | null | undefined);
+    get value(): IusSelectValue | IusSelectValue[] | null;
+    /** Texto del label (sobre el campo, con `:` final). */
+    label?: string;
+    /** Indicador de obligatorio (•). */
+    required: boolean;
+    /** Placeholder cuando no hay selección. */
+    placeholder: string;
+    /** Ícono Material Symbols a la izquierda del campo. */
+    prefixIcon?: string;
+    /** Mostrar la caja de búsqueda dentro del menú. */
+    searchable: boolean;
+    /** Placeholder de la caja de búsqueda. */
+    searchPlaceholder: string;
+    /** Mensaje cuando la búsqueda no arroja resultados. */
+    emptyText: string;
+    /** Opciones visibles antes de hacer scroll. */
+    maxVisible: number;
+    /** Texto de ayuda bajo el campo (estado normal). */
+    helpText?: string;
+    /** Texto de error bajo el campo (sustituye a `helpText` cuando `error`). */
+    errorText?: string;
+    /** Mostrar/ocultar el texto de ayuda. */
+    showHelpText: boolean;
+    /** Ícono de ayuda `?` junto al label. */
+    showIconHelp: boolean;
+    /** Título del contenido de ayuda. */
+    iconHelpTitle?: string;
+    /** Cuerpo del contenido de ayuda. */
+    iconHelpContent?: string;
+    /**
+     * Mostrar el botón de limpiar (`cancel`). Solo aparece con valor y campo
+     * habilitado. `false` lo oculta siempre.
+     */
+    showClear: boolean;
+    /** Abrir el menú al montar (no controlado). */
+    defaultOpen: boolean;
+    /** Variante compacta (sin ancho mínimo, padding reducido). Usado por SelectNumber. */
+    compact: boolean;
+    /** Valor inicial no controlado. */
+    defaultValue?: IusSelectValue | IusSelectValue[];
+    /** `id` del campo (para el label). */
+    id?: string;
+    /** `name` del control. */
+    name?: string;
+    /** Cambio de valor (original `onChange`). Habilita `[(value)]`. */
+    readonly valueChange: EventEmitter<IusSelectValue | IusSelectValue[] | null>;
+    /** Al limpiar el campo (original `onClear`). */
+    readonly cleared: EventEmitter<void>;
+    /** Cambio de apertura del menú (original `onOpenChange`). */
+    readonly openChange: EventEmitter<boolean>;
+    private readonly internalOpen;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly menuPos: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+        width: number;
+        placement: "bottom" | "top";
+    }>;
+    private readonly field;
+    private readonly menu;
+    private readonly search;
+    protected readonly baseId: string;
+    protected readonly helpId: string;
+    private onChange;
+    private onTouched;
+    private raf;
+    private readonly repositionBound;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    /** `data-focused` del host (espejo del golden): abierto, forzado o error. */
+    protected readonly focusedAttr: _angular_core.Signal<true | null>;
+    private readonly allFlat;
+    protected readonly visible: _angular_core.Signal<VisibleModel>;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    protected readonly valueArray: _angular_core.Signal<IusSelectValue[]>;
+    protected readonly singleValue: _angular_core.Signal<IusSelectValue | null>;
+    protected get hint(): string | undefined;
+    protected get showHint(): boolean;
+    protected get showClearComputed(): boolean;
+    protected get helpIconTitle(): string | undefined;
+    protected get listMaxH(): number;
+    protected labelFor(val: IusSelectValue): string;
+    protected isChosen(val: IusSelectValue): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: IusSelectValue | IusSelectValue[] | null): void;
+    registerOnChange(fn: (value: IusSelectValue | IusSelectValue[] | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private commit;
+    protected handleSelect(opt: SelectOption): void;
+    protected removeChip(val: IusSelectValue): void;
+    protected clear(event: Event): void;
+    protected toggleOpen(): void;
+    private setOpen;
+    protected onSearch(event: Event): void;
+    private moveActive;
+    protected onTriggerKeyDown(event: KeyboardEvent): void;
+    protected onDocumentMouseDown(event: MouseEvent): void;
+    protected onEscape(): void;
+    private scheduleReposition;
+    private reposition;
+    private attachListeners;
+    private teardownListeners;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "ius-select", never, { "options": { "alias": "options"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "error": { "alias": "error"; "required": false; }; "state": { "alias": "state"; "required": false; }; "open": { "alias": "open"; "required": false; }; "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "maxVisible": { "alias": "maxVisible"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "showHelpText": { "alias": "showHelpText"; "required": false; }; "showIconHelp": { "alias": "showIconHelp"; "required": false; }; "iconHelpTitle": { "alias": "iconHelpTitle"; "required": false; }; "iconHelpContent": { "alias": "iconHelpContent"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "valueChange": "valueChange"; "cleared": "cleared"; "openChange": "openChange"; }, never, never, true, never>;
+    static ngAcceptInputType_multiple: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_error: unknown;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_searchable: unknown;
+    static ngAcceptInputType_maxVisible: unknown;
+    static ngAcceptInputType_showHelpText: unknown;
+    static ngAcceptInputType_showIconHelp: unknown;
+    static ngAcceptInputType_showClear: unknown;
+    static ngAcceptInputType_defaultOpen: unknown;
+    static ngAcceptInputType_compact: unknown;
+}
+
+/**
+ * Un paso del asistente.
+ *
+ * `content` (que en el golden React es un `ReactNode`) se resuelve en Angular
+ * con un `TemplateRef` por paso (ng-spec §2 / §7): el consumidor declara un
+ * `<ng-template>` por paso y lo pasa aquí.
+ */
+interface WizardStep {
+    /** Identificador opcional del paso. */
+    key?: string;
+    /** Nombre visible del paso (etiqueta "Paso X de N · label"). */
+    label?: string;
+    /** Contenido del paso (típicamente un formulario), como plantilla. */
+    content?: TemplateRef<unknown> | null;
+}
+/** API que devuelve `createWizard(...)` y consumen `<ius-wizard>` y `<ius-wizard-nav>`. */
+interface WizardApi {
+    /** Pasos del flujo. */
+    readonly steps: WizardStep[];
+    /** Total de pasos. */
+    readonly total: number;
+    /** Paso actual (1-based). Reactivo (signal-backed). */
+    readonly step: number;
+    /** Índice actual (0-based). */
+    readonly index: number;
+    /** Paso actual (`steps[index]`). */
+    readonly current: WizardStep | null;
+    /** `true` en el primer paso. */
+    readonly isFirst: boolean;
+    /** `true` en el último paso. */
+    readonly isLast: boolean;
+    /** Avanza un paso; en el último, dispara `onFinish`. */
+    next(): void;
+    /** Retrocede un paso (no baja de 1). */
+    back(): void;
+    /** Salta a un paso (1-based), o función `(prev) => next`. */
+    goTo(next: number | ((prev: number) => number)): void;
+}
+interface UseWizardOptions {
+    /** Pasos del flujo. */
+    steps: WizardStep[];
+    /** Paso inicial (no controlado). Default 1. */
+    defaultStep?: number;
+    /**
+     * Paso inicial controlado (1-based). En el port Angular el estado siempre
+     * vive en el controller (signal); pásalo para sembrar el paso inicial y
+     * observa los cambios con `onStepChange` / fuérzalos con `goTo`.
+     */
+    step?: number;
+    /** Cambio de paso (recibe el nuevo paso 1-based). */
+    onStepChange?: (step: number) => void;
+    /** Se dispara al pulsar "siguiente" en el último paso (cierre del flujo). */
+    onFinish?: () => void;
+}
+/**
+ * Controller de estado del Wizard — equivalente Angular del hook `Wizard.use`
+ * de React (ng-spec §2). El paso vive en un `signal` interno, así que leer
+ * `api.step` / `api.current` / `api.isLast` en una plantilla registra la
+ * dependencia y refresca los componentes `OnPush` que consumen la `api`.
+ */
+declare class WizardController implements WizardApi {
+    readonly steps: WizardStep[];
+    private readonly _step;
+    /** Señal de solo lectura del paso (por si el consumidor la quiere directa). */
+    readonly step$: Signal<number>;
+    private readonly onStepChange?;
+    private readonly onFinish?;
+    constructor(options: UseWizardOptions);
+    get total(): number;
+    get step(): number;
+    get index(): number;
+    get current(): WizardStep | null;
+    get isFirst(): boolean;
+    get isLast(): boolean;
+    goTo: (next: number | ((prev: number) => number)) => void;
+    next: () => void;
+    back: () => void;
+}
+/**
+ * `createWizard(options)` — fábrica del estado del asistente (equivalente a
+ * `Wizard.use(...)`). Devuelve la `WizardApi` que leen `<ius-wizard>` y
+ * `<ius-wizard-nav>`.
+ */
+declare function createWizard(options: UseWizardOptions): WizardApi;
+
+/**
+ * Wizard (body) — Ius Design v2.
+ *
+ * Cuerpo del asistente: indicador de progreso + etiqueta "Paso X de N · label"
+ * + el contenido del paso activo. **Agnóstico del contenedor** — vive en el
+ * body de un Drawer/Modal o de una página; el footer (`ius-wizard-nav`) lee la
+ * misma `api`. Distinto del `Stepper` (indicador display-only).
+ *
+ * El estado lo gobierna el controller `createWizard(...)` (ver `wizard.ts`),
+ * espejo del hook `Wizard.use` de React (ng-spec §2).
+ *
+ * Nota del port: el indicador por defecto del golden es `LinearProgressBar`
+ * (aún no portado); aquí se inlinea su modo "steps" (`.ius-lpb`, fill/rest)
+ * fiel al golden. Cuando exista `ius-linear-progress-bar`, reemplazar por
+ * composición sin cambiar la API. `indicator` permite pasar un nodo propio.
+ */
+declare class WizardComponent {
+    /** API de `createWizard(...)`. */
+    api: WizardApi;
+    /** Muestra el indicador de progreso (por defecto la barra "steps"). */
+    showIndicator: boolean;
+    /** Indicador personalizado (reemplaza la barra por defecto). */
+    indicator?: TemplateRef<unknown>;
+    /** Muestra la etiqueta "Paso X de N · label". */
+    showStepLabel: boolean;
+    /** Palabra para "Paso". */
+    stepWord: string;
+    /** Palabra para "de". */
+    ofWord: string;
+    /** Porcentaje del indicador (step/total), espejo del modo stepped del LPB. */
+    protected get percent(): number;
+    protected get ariaNow(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WizardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WizardComponent, "ius-wizard", never, { "api": { "alias": "api"; "required": true; }; "showIndicator": { "alias": "showIndicator"; "required": false; }; "indicator": { "alias": "indicator"; "required": false; }; "showStepLabel": { "alias": "showStepLabel"; "required": false; }; "stepWord": { "alias": "stepWord"; "required": false; }; "ofWord": { "alias": "ofWord"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_showIndicator: unknown;
+    static ngAcceptInputType_showStepLabel: unknown;
+}
+
+/**
+ * WizardNav (footer) — Ius Design v2.
+ *
+ * Footer de navegación del asistente: **Atrás** (secondary, deshabilitado en el
+ * primero — o `hideBackOnFirst` para ocultarlo) + **Siguiente** (primary, ícono
+ * `arrow_forward`); en el último paso, Siguiente pasa a **Guardar**
+ * (`finishDynamic` activa el modo dynamic loading → success del Button).
+ *
+ * Pensado para el slot `footer` del Drawer/Modal o el footer propio de una
+ * página. Lee la misma `api` que `<ius-wizard>`. Compone `ius-button`.
+ *
+ * El handler final se pasa como `finishAction` (con `finishDynamic` debe
+ * devolver una `Promise` para integrarse con el modo dynamic del Button);
+ * además se emite el output `finish` (ng-spec §4).
+ */
+declare class WizardNavComponent {
+    /** API de `createWizard(...)`. */
+    api: WizardApi;
+    /** Etiqueta del botón atrás. */
+    backLabel: string;
+    /** Etiqueta del botón siguiente. */
+    nextLabel: string;
+    /** Etiqueta del botón final (último paso). */
+    finishLabel: string;
+    /** Ícono al final del botón siguiente. */
+    nextIcon: string;
+    /** El botón final usa el modo `dynamic` del Button (loading → success). */
+    finishDynamic: boolean;
+    /** Deshabilita "siguiente" (p. ej. validación del paso pendiente). */
+    nextDisabled: boolean;
+    /** Oculta el botón atrás en el primer paso (en vez de deshabilitarlo). */
+    hideBackOnFirst: boolean;
+    /**
+     * Handler del botón final. Con `finishDynamic` debe devolver una `Promise`
+     * (su resolución decide success/error del Button).
+     */
+    finishAction?: () => void | IusButtonActionResult | Promise<IusButtonActionResult | void>;
+    /** Se dispara al pulsar el botón final (original `onFinish`). */
+    readonly finish: EventEmitter<void>;
+    /** `action` para el modo dynamic del Button: emite `finish` y espera el handler. */
+    protected readonly runFinish: () => Promise<IusButtonActionResult | void>;
+    /** Click del botón final en modo NO dynamic. */
+    protected onFinishClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WizardNavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WizardNavComponent, "ius-wizard-nav", never, { "api": { "alias": "api"; "required": true; }; "backLabel": { "alias": "backLabel"; "required": false; }; "nextLabel": { "alias": "nextLabel"; "required": false; }; "finishLabel": { "alias": "finishLabel"; "required": false; }; "nextIcon": { "alias": "nextIcon"; "required": false; }; "finishDynamic": { "alias": "finishDynamic"; "required": false; }; "nextDisabled": { "alias": "nextDisabled"; "required": false; }; "hideBackOnFirst": { "alias": "hideBackOnFirst"; "required": false; }; "finishAction": { "alias": "finishAction"; "required": false; }; }, { "finish": "finish"; }, never, never, true, never>;
+    static ngAcceptInputType_finishDynamic: unknown;
+    static ngAcceptInputType_nextDisabled: unknown;
+    static ngAcceptInputType_hideBackOnFirst: unknown;
+}
+
+/** Eje con scroll. */
+type IusScrollAxis = 'y' | 'x' | 'both';
+/** Grosor de la barra — `thin` es alias de `small`. */
+type IusScrollSize = 'small' | 'medium' | 'large' | 'thin';
+/**
+ * ScrollArea — Ius Design v2.
+ *
+ * Contenedor con scroll **canónico** del sistema: aplica la barra unificada
+ * (utilidad global `.ius-scroll` de `tokens/scrollbar.css`) para que cualquier
+ * área desplazable tenga el mismo thumb pill `neutral-4` (hover `neutral-5`,
+ * track transparente) sin reescribir reglas `::-webkit-scrollbar`. **No** para
+ * el scroll de toda la página (eso lo maneja el documento).
+ *
+ * Nota del port: el `as` polimórfico del golden no aplica — el host es siempre
+ * `<ius-scroll-area>` (`.ius-sa`). El `viewRef` de React se expone como
+ * `getViewport()` (equivalente a un `@ViewChild` del viewport).
+ */
+declare class ScrollAreaComponent implements AfterViewInit, OnChanges, OnDestroy {
+    /** Eje con scroll. */
+    axis: IusScrollAxis;
+    /** Grosor de barra; `thin` = alias de `small`. */
+    size: IusScrollSize;
+    /** Thumb solo visible en hover/foco (lienzos amplios). */
+    autoHide: boolean;
+    /** Máscara de gradiente en los bordes con scroll disponible. */
+    fade: boolean;
+    /** Límite que dispara el scroll vertical (número → px). */
+    maxHeight?: number | string;
+    /** Límite que dispara el scroll horizontal (número → px). */
+    maxWidth?: number | string;
+    /** Clase(s) extra para el viewport. */
+    viewClassName?: string;
+    /** Reenvía el evento nativo `scroll` del viewport (opcional, ng-spec §3). */
+    readonly scrolled: EventEmitter<Event>;
+    private readonly view;
+    private ro;
+    private readonly onScroll;
+    /** Clases del viewport: base + barra unificada + variante de tamaño/autoHide. */
+    protected get viewClasses(): string;
+    protected get maxHeightCss(): string | null;
+    protected get maxWidthCss(): string | null;
+    private toCss;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    /** Acceso al viewport (equivalente al `viewRef` del golden). */
+    getViewport(): HTMLElement | null;
+    private updateFade;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollAreaComponent, "ius-scroll-area", never, { "axis": { "alias": "axis"; "required": false; }; "size": { "alias": "size"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; "fade": { "alias": "fade"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "viewClassName": { "alias": "viewClassName"; "required": false; }; }, { "scrolled": "scrolled"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_autoHide: unknown;
+    static ngAcceptInputType_fade: unknown;
+}
+
+/** Tamaño de la fila — heredado del Select. small · medium (default) · large. */
+type IusOptionItemSize = 'small' | 'medium' | 'large';
+/**
+ * Estado forzado — **solo demos/especímenes del DS**. En producción usar
+ * `selected`/`multi`/`active`/`disabled`. Sobrescribe la interacción real.
+ */
+type IusOptionItemState = 'idle' | 'hover' | 'pressed' | 'disabled' | 'selected' | 'selectedVar' | 'selectedHovered';
+/**
+ * OptionItem — Ius Design.
+ *
+ * Átomo de **fila de opción** dentro del menú (MenuInput) del **Select** (y
+ * SelectNumber, y cualquier lista de opciones del sistema). **No se usa suelto en
+ * formularios** — es la pieza interna que renderiza cada opción. Cubre los 7
+ * estados del especimen Figma: Default · Hovered · Pressed · Disabled · Selected
+ * (multi, check circular al final) · Selected Var (single, relleno azul) ·
+ * Selected Hovered.
+ *
+ * Regla de marca: `multi` + `selected` → check (Selected); single + `selected` →
+ * relleno azul (Selected Var). `active` es el resaltado de navegación por teclado
+ * (mismo fondo que hover) sin marcar la opción como elegida.
+ *
+ * Fuente de verdad: `components/inputs/OptionItem/OptionItem.jsx` + `.d.ts` +
+ * `OptionItem.ng-spec.md`. Todo sale de tokens `--ius-*` (los px 6/11/22 son los
+ * mismos valores crudos que fija el golden para el alto de fila y el disco del
+ * check — excepción documentada por la fuente de verdad).
+ */
+declare class OptionItemComponent {
+    /** Texto de la opción. Alternativa a la proyección de contenido. */
+    label?: string;
+    /** Ícono Material Symbols a la izquierda (opcional). */
+    icon?: string;
+    /** La opción está elegida. */
+    selected: boolean;
+    /** Selección múltiple: con `selected` → check circular (si no, relleno azul). */
+    multi: boolean;
+    /** Resaltado de navegación por teclado (activa, sin elegir aún). */
+    active: boolean;
+    /** Opción no seleccionable. */
+    disabled: boolean;
+    /** Tamaño de la fila, heredado del Select. */
+    size: IusOptionItemSize;
+    /** Valor de la opción (para `role="option"` / aria). */
+    value?: string | number;
+    /** Estado forzado — **solo demos/especímenes**. */
+    state?: IusOptionItemState;
+    /** Al elegir la opción (original `onSelect`). */
+    readonly selectClicked: EventEmitter<void>;
+    /** ¿Hay un estado forzado activo (demo)? */
+    protected get forced(): boolean;
+    /** ¿La opción se ve como elegida (real o forzada)? */
+    protected get isSelected(): boolean;
+    /** ¿Elegida en modo múltiple (check) vs single (relleno)? */
+    protected get isMultiSel(): boolean;
+    /** Marca de elegido: `check` (multi) o `fill` (single). */
+    protected get variant(): 'check' | 'fill';
+    /** Deshabilitada (real o forzada). */
+    protected get isDisabled(): boolean;
+    /** ¿Mostrar el disco de check al final (solo multi elegido)? */
+    protected get showCheck(): boolean;
+    protected handleClick(): void;
+    protected onMouseDown(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OptionItemComponent, "ius-option-item", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "multi": { "alias": "multi"; "required": false; }; "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "value": { "alias": "value"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "selectClicked": "selectClicked"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_selected: unknown;
+    static ngAcceptInputType_multi: unknown;
+    static ngAcceptInputType_active: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Tamaño del chip — small ~24 · medium ~28 (default) · large ~32px (alineado a inputs). */
+type IusChipSize = 'small' | 'medium' | 'large';
+/** Estado forzado — **solo demos/especímenes del DS**. Sobrescribe la interacción real. */
+type IusChipState = 'idle' | 'hover' | 'disabled';
+/**
+ * Chip — Ius Design.
+ *
+ * Etiqueta compacta tipo "pill" que representa un valor seleccionado. Dos modos:
+ * - **Eliminable** (`removable`): relleno azul + botón × circular. Para inputs y
+ *   formularios (lo usan Select / CascaderSelect en multiselección) — cada chip es
+ *   un valor elegido que el usuario puede quitar.
+ * - **No eliminable** (default): blanco con borde. Para vistas de solo lectura /
+ *   display.
+ *
+ * Tres estados (Default · Hovered · Disabled) y tres tamaños. Admite un ícono a la
+ * izquierda. **No** es interactivo (no clickable/toggle) ni maneja color de estado
+ * → para eso usar **Tag**.
+ *
+ * Fuente de verdad: `components/data-display/Chip/Chip.jsx` + `.d.ts` + ng-spec.
+ * Todo sale de tokens `--ius-*`; los px de la pill (3/4/5 py, 8/10/12 px, 16/18/20
+ * de la ×) son los valores que fija el golden para el alto por tamaño (excepción
+ * documentada por la fuente de verdad).
+ */
+declare class ChipComponent {
+    /** Texto del chip. Alternativa a la proyección de contenido. */
+    label?: string;
+    /** Ícono Material Symbols a la izquierda (opcional). */
+    icon?: string;
+    /** Muestra el botón × y habilita quitar el chip (relleno azul). */
+    removable: boolean;
+    /** Tamaño de la pill. */
+    size: IusChipSize;
+    /** Deshabilitado (atenuado, × no funcional). */
+    disabled: boolean;
+    /** Estado forzado — **solo demos/especímenes**. */
+    state?: IusChipState;
+    /** aria-label del botón quitar. */
+    removeLabel: string;
+    /** Al pulsar la × (original `onRemove`). */
+    readonly removed: EventEmitter<void>;
+    /** Deshabilitado (real o forzado). */
+    protected get isDisabled(): boolean;
+    /** `data-state` solo cuando hay un estado forzado (≠ idle). */
+    protected get forcedState(): IusChipState | null;
+    protected handleRemove(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipComponent, "ius-chip", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; "removeLabel": { "alias": "removeLabel"; "required": false; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_removable: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+type IusFlexDirection = 'row' | 'column';
+type IusFlexGap = 'none' | 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
+type IusFlexAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+type IusFlexJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+/**
+ * Flex — primitivo de maquetación (ng-spec components/layout/Flex).
+ *
+ * Contenedor flexbox cuyo `gap` está RESTRINGIDO a la escala --ius-space-*
+ * (no existe gap numérico libre: esa restricción es el punto del componente).
+ * Reemplaza el `<div style="display:flex; gap:…">` a mano.
+ *
+ * Sin estilos propios: todas las reglas viven en la librería de estilos
+ * (tokens.css › sección layout.css, clases .ius-flex + data-attrs) — este
+ * componente es azúcar que emite la clase y los atributos.
+ *
+ * El `as` de la spec se resuelve con el selector de ATRIBUTO, sin nodo extra:
+ *   <nav ius-flex gap="sm">…</nav>  ·  <ul ius-flex direction="column">…</ul>
+ * La forma de elemento también es válida: <ius-flex gap="lg">…</ius-flex>.
+ *
+ * Solo estructura: no aporta cáscara de página (AppLayout), superficie (Card)
+ * ni tipografía (Text). Sin outputs, sin estado, sin user-select.
+ */
+declare class FlexComponent {
+    /** Eje principal; 'column' = patrón stack. Solo emite data-dir en column. */
+    direction: IusFlexDirection;
+    /** Separación entre hijos — SOLO escala --ius-space-*. */
+    gap: IusFlexGap;
+    /** align-items; sin valor no se emite (default del navegador: stretch). */
+    align?: IusFlexAlign;
+    /** justify-content; sin valor no se emite (default: flex-start). */
+    justify?: IusFlexJustify;
+    /** flex-wrap: wrap (patrón cluster). */
+    wrap: boolean;
+    /** inline-flex en vez de flex (grupos que fluyen dentro de texto). */
+    inline: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlexComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlexComponent, "ius-flex, [ius-flex]", never, { "direction": { "alias": "direction"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "align": { "alias": "align"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+type IusDividerOrientation = 'horizontal' | 'vertical';
+type IusDividerVariant = 'solid' | 'dashed';
+type IusDividerTextAlign = 'start' | 'center' | 'end';
+/**
+ * Divider — separador NEUTRO (ng-spec components/data-display/Divider).
+ * Línea fina 1px --ius-neutral-3, horizontal (con etiqueta opcional proyectada)
+ * o vertical (rellena el alto del contenedor). Para separadores con tono
+ * semántico → Alert o borde propio. Sin outputs.
+ *
+ * Etiqueta: contenido proyectado (solo horizontal). textAlign mueve el trazo
+ * corto (stub) al lado del título, como el golden.
+ */
+declare class DividerComponent implements AfterViewInit {
+    /** Eje; vertical rellena el alto del contenedor (sin etiqueta). */
+    orientation: IusDividerOrientation;
+    /** dashed = separación suave. */
+    variant: IusDividerVariant;
+    /** Alineación de la etiqueta (solo horizontal con etiqueta). */
+    textAlign: IusDividerTextAlign;
+    private labelWrap;
+    protected readonly hasLabel: _angular_core.WritableSignal<boolean>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "ius-divider", never, { "orientation": { "alias": "orientation"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+export { AlertComponent, AvatarComponent, ButtonComponent, CaptchaFieldComponent, CarouselComponent, CheckboxComponent, ChipComponent, CircularProgressComponent, CodeFieldComponent, CountdownComponent, CountdownRingComponent, DescriptionListComponent, DividerComponent, EleniaBubbleComponent, EleniaOrbComponent, EmptyStateComponent, FlexComponent, HeaderBarComponent, ILLUSTRATIONS, ILLUSTRATION_ALIAS, ILLUSTRATION_NAMES, IconButtonComponent, IllustrationComponent, IusAlertActionsDirective, IusAlertTrailingDirective, IusModalFooterDirective, IusTagPrefixDirective, IusTagSuffixDirective, LoadingComponent, LoadingMarkComponent, ModalComponent, MultiTextFieldComponent, NavUserComponent, ORB_PERIODS, OauthButtonComponent, OptionItemComponent, PopoverComponent, ScrollAreaComponent, SegmentedControlComponent, SelectComponent, ShowMoreComponent, StatusStateComponent, TagComponent, TextButtonComponent, TextComponent, TextFieldComponent, TooltipComponent, WizardComponent, WizardController, WizardNavComponent, createWizard, pose, poseIso, poseSpeaking, poseThinking, renderCubeSvg, resolveIllustration, voiceEnv };
+export type { AlertSize, AlertTone, AlertVariant, CountdownDirection, CountdownFormat, CountdownRingSize, CountdownRingTone, DescriptionListItem, DescriptionListLayout, DescriptionListSize, DescriptionListValueClick, IllustrationEntry, IllustrationName, IllustrationSize, IusAvatarColor, IusAvatarShape, IusAvatarSize, IusButtonActionResult, IusButtonSize, IusButtonStatus, IusButtonType, IusButtonVariant, IusCaptchaAppearance, IusCaptchaFieldHandle, IusCaptchaProvider, IusCaptchaSize, IusCaptchaState, IusCaptchaTheme, IusCarouselImage, IusCarouselImageInput, IusCarouselObjectFit, IusCarouselOrder, IusCarouselOverlay, IusCarouselTransition, IusCheckboxLabelPosition, IusCheckboxSize, IusChipSize, IusChipState, IusCircularProgressSize, IusCircularProgressTone, IusCodeFieldSize, IusDividerOrientation, IusDividerTextAlign, IusDividerVariant, IusEleniaBubblePosition, IusEleniaBubbleSize, IusEleniaOrbMood, IusEleniaOrbSurface, IusEmptyStateAction, IusEmptyStateSize, IusEmptyStateTone, IusEmptyStateVariant, IusFlexAlign, IusFlexDirection, IusFlexGap, IusFlexJustify, IusIconButtonShape, IusIconButtonSize, IusIconButtonVariant, IusLoadingMarkSurface, IusLoadingVariant, IusModalCloseReason, IusModalIconTone, IusModalSize, IusMultiTextFieldSize, IusMultiTextFieldSlot, IusMultiTextFieldState, IusNavUserAccount, IusNavUserLayout, IusNavUserUser, IusOAuthButtonSize, IusOAuthButtonType, IusOAuthProvider, IusOptionItemSize, IusOptionItemState, IusPopoverPadding, IusPopoverPlacement, IusPopoverTrigger, IusScrollAxis, IusScrollSize, IusSegmentedSize, IusSegmentedVariant, IusSelectSize, IusSelectState, IusSelectValue, IusShowMoreAlign, IusStatusKind, IusTagRole, IusTagShape, IusTagSize, IusTagState, IusTagTone, IusTagVariant, IusTextAlign, IusTextButtonSize, IusTextButtonType, IusTextColor, IusTextFieldSize, IusTextFieldType, IusTextTag, IusTextVariant, IusTextWeight, IusTooltipTrigger, OrbMood, OrbPose, SegmentedOption, SelectOption, SelectOptionGroup, UseWizardOptions, WizardApi, WizardStep };