npm - @litigiovirtual/ius-design-components - Versions diffs - 2.0.3 → 2.0.5 - Mend

@litigiovirtual/ius-design-components 2.0.3 → 2.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +14 -14
package/fesm2022/litigiovirtual-ius-design-components-utils.mjs +6 -6
package/fesm2022/litigiovirtual-ius-design-components-utils.mjs.map +1 -1
package/fesm2022/litigiovirtual-ius-design-components.mjs +2307 -225
package/fesm2022/litigiovirtual-ius-design-components.mjs.map +1 -1
package/package.json +1 -1
package/types/litigiovirtual-ius-design-components.d.ts +1350 -25

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

@@ -2365,6 +2365,12 @@ interface SelectOptionGroup {
     label: string;
     options: SelectOption[];
 }
+/**
+ * Fábrica de opciones para `creatable`: recibe el texto escrito en el pie del
+ * menú y devuelve la opción a insertar. Devolver `void`/`undefined` usa el
+ * texto como `value` y `label` (espejo de `onCreate` del golden).
+ */
+type IusSelectCreateFactory = (label: string) => SelectOption | void;
 interface VisibleGroup {
     label: string | null;
     items: {
@@ -2381,9 +2387,10 @@ interface VisibleModel {
  *
  * 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)]`.
+ * y abre un menú con **scroll**, **búsqueda en vivo** (caja dentro del menú),
+ * **selección única o múltiple** y —con `creatable`— un **pie para agregar
+ * opciones nuevas en vivo**. 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.
@@ -2393,9 +2400,10 @@ interface VisibleModel {
  * 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 golden compone `OptionItem` (filas), `Chip` (chips de múltiple),
+ *   `Popover` (ícono de ayuda) y `TextButton` (acción del pie `creatable`):
+ *   todos ya portados, se componen aquí como `ius-option-item` / `ius-chip` /
+ *   `ius-popover` / `ius-text-button` (sin CSS inlineado ni reimplementación).
  * - El menú se portalea a `document.body` vía **CDK Overlay**
  *   (`flexibleConnectedTo` el trigger + `scrollStrategy: reposition`), con
  *   flip abajo/arriba e igualando el ancho del campo — espejo de
@@ -2403,6 +2411,24 @@ interface VisibleModel {
  *   estilos del menú siguen aplicando dentro del overlay porque Angular
  *   inyecta el `<style>` scopeado en el `<head>` global (mismo patrón que
  *   `ius-modal`, ver `src/lib/modal/modal.component.ts`).
+ *
+ * **Creatable — decisiones del port** (para diseño):
+ * - El golden implementa `creatable` como un **pie propio del menú** con su
+ *   campo de texto (`draft`) + `TextButton prefixIcon="add"`, *independiente*
+ *   de la caja de búsqueda (conviven). NO es el patrón «la opción nueva
+ *   aparece dentro de la lista cuando la búsqueda no matchea ninguna opción»;
+ *   si diseño quisiera ese otro patrón, primero hay que cambiar el golden.
+ * - `onCreate` del golden **retorna** la opción a insertar. Un `EventEmitter`
+ *   de Angular no puede devolver un valor al emisor, así que el contrato se
+ *   parte en dos: `createFactory` (input — la mitad que retorna) + `created`
+ *   (output — la mitad que avisa). Ver el TSDoc de cada uno.
+ *
+ * **Divergencia doc-vs-golden anotada** (manda el golden):
+ * - `listMaxH` usa la escala de fila del golden (32/38/46 px por
+ *   small/medium/large). El box-model real de `OptionItem` da 32/36/42; el
+ *   golden la llama «approx option row height by size» y deja aire de sobra
+ *   para el `gap` entre filas. Se conserva la del golden para que `maxVisible`
+ *   recorte igual que en el DS.
  */
 declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy {
     private readonly optionsState;
@@ -2453,6 +2479,26 @@ declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy
     searchPlaceholder: string;
     /** Mensaje cuando la búsqueda no arroja resultados. */
     emptyText: string;
+    /**
+     * Permitir **agregar opciones** desde un pie dentro del menú (campo de texto
+     * + botón «Agregar» con ícono `add`). Las opciones nuevas se anexan a la
+     * lista en vivo —a un grupo sin encabezado al final si la lista está
+     * agrupada— y no duplican `value` existentes. Convive con `searchable`.
+     */
+    creatable: boolean;
+    /** Placeholder del campo de «agregar» (solo con `creatable`). */
+    createPlaceholder: string;
+    /** Texto del botón de «agregar» (solo con `creatable`). */
+    createLabel: string;
+    /**
+     * Fábrica de la opción a insertar — equivalente Angular de `onCreate` del
+     * golden, que **retorna** la opción. Un `EventEmitter` no puede devolver un
+     * valor al emisor, así que la mitad «que retorna» del contrato vive aquí
+     * como input y la mitad «que avisa» vive en el output `created`.
+     * Recibe el texto escrito (ya con `trim`) y devuelve `{value,label,icon?}`;
+     * devolver `void`/`undefined` usa el texto como `value` y `label`.
+     */
+    createFactory?: IusSelectCreateFactory;
     /** Opciones visibles antes de hacer scroll. */
     maxVisible: number;
     /** Texto de ayuda bajo el campo (estado normal). */
@@ -2461,11 +2507,11 @@ declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy
     errorText?: string;
     /** Mostrar/ocultar el texto de ayuda. */
     showHelpText: boolean;
-    /** Ícono de ayuda `?` junto al label. */
+    /** Ícono de ayuda `?` junto al label (abre `ius-popover` al hover/foco). */
     showIconHelp: boolean;
-    /** Título del contenido de ayuda. */
+    /** Título del popover de ayuda. */
     iconHelpTitle?: string;
-    /** Cuerpo del contenido de ayuda. */
+    /** Cuerpo del popover de ayuda. */
     iconHelpContent?: string;
     /**
      * Mostrar el botón de limpiar (`cancel`). Solo aparece con valor y campo
@@ -2488,19 +2534,37 @@ declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy
     readonly cleared: EventEmitter<void>;
     /** Cambio de apertura del menú (original `onOpenChange`). */
     readonly openChange: EventEmitter<boolean>;
+    /**
+     * Opción agregada por `creatable` — mitad «aviso» del `onCreate` del golden
+     * (la mitad «que retorna la opción» es el input `createFactory`). Solo emite
+     * cuando la opción se anexó de verdad: un texto cuyo `value` ya existe en la
+     * lista no emite nada.
+     */
+    readonly created: EventEmitter<SelectOption>;
     private readonly internalOpen;
     protected readonly query: _angular_core.WritableSignal<string>;
     protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    /** Texto en curso del pie `creatable` (se limpia al agregar y al cerrar). */
+    protected readonly draft: _angular_core.WritableSignal<string>;
+    /** Opciones agregadas en vivo por `creatable` (se anexan a `options`). */
+    private readonly createdOptions;
     /** Ancho del menú (portal CDK) — igualado al ancho del campo. */
     protected readonly menuWidth: _angular_core.WritableSignal<number>;
     private readonly field;
     private readonly menu;
     private readonly search;
+    private readonly createInput;
     private readonly menuTpl;
-    protected readonly baseId: string;
-    protected readonly helpId: string;
+    /**
+     * `id` de respaldo. `baseId` NO puede ser un inicializador de campo: esos
+     * corren en el constructor, antes de que Angular asigne los `@Input`, así que
+     * `this.id` valdría siempre `undefined` y el `id` del consumidor se perdería.
+     */
+    private readonly fallbackId;
+    protected get baseId(): string;
+    protected get helpId(): string;
     /** `id` único del menú — target de `aria-controls` en el trigger. */
-    protected readonly menuId: string;
+    protected get menuId(): string;
     private onChange;
     private onTouched;
     private readonly overlay;
@@ -2511,31 +2575,65 @@ declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy
     private typeaheadTimer;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly isError: _angular_core.Signal<boolean>;
+    /**
+     * Apertura efectiva. `state="open"` entra aquí (y no solo en `ngOnInit`) para
+     * que forzar el estado desde un especimen funcione en caliente, igual que el
+     * card remontado del proyecto de diseño.
+     */
     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>;
+    /**
+     * Opciones efectivas = las de `options` + las agregadas en vivo por
+     * `creatable`. Si la lista viene agrupada, las nuevas van a un grupo sin
+     * encabezado al final (espejo de `mergedOptions` del golden).
+     */
+    private readonly mergedOptions;
     private readonly allFlat;
     protected readonly visible: _angular_core.Signal<VisibleModel>;
+    /** El botón «Agregar» se habilita solo con texto no vacío (golden). */
+    protected readonly createDisabled: _angular_core.Signal<boolean>;
     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;
     /**
-     * Alto de fila usado para `maxVisible × itemH` — deriva del box-model real
-     * de `OptionItem` (`option-item.component.scss`): `--_opt-py` (padding
-     * vertical, top+bottom) + `--ius-lh-base` (line-height, fija en 20px, no
-     * cambia por tamaño — solo el font-size lo hace). small py=6px → 32px ·
-     * medium py=8px (`--ius-space-xs`) → 36px · large py=11px → 42px. No
-     * incluye el `gap` entre filas de `.ius-selectmenu__list`
-     * (`--ius-space-xxs`) — constante estructural documentada, no medida en
+     * ¿El campo es "clearable-capable"? Espejo de `clearReserved` del golden: solo
+     * entonces el botón de limpiar entra en el flujo (y dentro de ese caso el slot
+     * se reserva con `visibility`). Con `showClear=false` o `disabled` el golden no
+     * pinta el botón, así que tampoco debe quedar el hueco.
+     */
+    protected get clearReserved(): boolean;
+    /** El popover de ayuda solo tiene sentido con título o contenido. */
+    protected get iconHelpEmpty(): boolean;
+    /**
+     * Tamaño de los chips de múltiple. El golden usa un chip **más pequeño que
+     * el campo**: `large → medium`, el resto `small`
+     * (`chipSize` en `Select.jsx`).
+     */
+    protected get chipSize(): 'small' | 'medium';
+    /** Tamaño del `TextButton` del pie `creatable` (golden: `large → medium`). */
+    protected get createButtonSize(): 'small' | 'medium';
+    /**
+     * Alto de fila usado para `maxVisible × itemH`. Escala del golden
+     * (`Select.jsx`: «approx option row height by size») — small 32 · medium 38
+     * · large 46 px. Es una aproximación *deliberadamente* mayor que el
+     * box-model real de `OptionItem` (`--_opt-py`×2 + `--ius-lh-base` = 32/36/42)
+     * porque deja aire para el `gap` (`--ius-space-xxs`) entre filas de
+     * `.ius-selectmenu__list`. Constante estructural del golden, no medida en
      * runtime.
      */
     protected get listMaxH(): number;
     protected labelFor(val: IusSelectValue): string;
     protected isChosen(val: IusSelectValue): boolean;
+    /**
+     * Única fuente del ciclo de vida del overlay: se monta y se desmonta según
+     * `isOpen()`, venga de donde venga (interno, `[open]` controlado o
+     * `state="open"` de un especimen). `attachOverlay` ya es idempotente.
+     */
+    private readonly openSync;
     ngOnInit(): void;
     ngOnDestroy(): void;
     writeValue(value: IusSelectValue | IusSelectValue[] | null): void;
@@ -2547,13 +2645,44 @@ declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy
     protected removeChip(val: IusSelectValue): void;
     protected clear(event: Event): void;
     protected toggleOpen(): void;
+    /**
+     * Solo actualiza estado y notifica. El montaje/desmontaje del overlay NO va
+     * aquí: lo gobierna `openSync` a partir de `isOpen()`. Si se hiciera aquí, en
+     * modo controlado (`[open]`) el menú se abriría sin permiso del padre y, al
+     * revés, cambiar `[open]` desde fuera no montaría nada.
+     */
     private setOpen;
+    /**
+     * El alto del menú cambió (filtro de búsqueda, alta de una opción por el pie
+     * `creatable`): re-evalúa flip/posición del overlay en el siguiente frame,
+     * cuando el DOM ya midió el alto nuevo.
+     */
+    private schedulePositionUpdate;
     protected onSearch(event: Event): void;
+    protected onCreateInput(event: Event): void;
+    /**
+     * `Enter` agrega la opción; `Escape` **con texto** solo limpia el borrador y
+     * frena la propagación para que el listener de `document` no cierre el menú
+     * (espejo del golden). Sin texto, `Escape` sigue cerrando el menú.
+     */
+    protected onCreateKeyDown(event: KeyboardEvent): void;
+    /**
+     * Agrega la opción escrita en el pie: la construye con `createFactory` (o
+     * envuelve el texto), la anexa si su `value` no existe ya, emite `created`,
+     * limpia el borrador y devuelve el foco al campo del pie.
+     */
+    protected addItem(): void;
     private moveActive;
     /**
      * ¿Es una tecla imprimible de una sola posición (typeahead)? Se ignora
-     * cuando el foco está en la caja de búsqueda (ahí escribir filtra, no
-     * hace typeahead) y cuando hay modificadores (Ctrl/Alt/Meta).
+     * cuando el foco está en una caja de texto del menú — la de búsqueda **o**
+     * la del pie `creatable`: ahí escribir filtra o redacta el nombre nuevo, y
+     * mover el resaltado sería un efecto colateral indeseado. También se ignora
+     * con modificadores (Ctrl/Alt/Meta).
+     *
+     * (Hoy el pie de `creatable` no enruta a `onTriggerKeyDown` —vive en el
+     * overlay y tiene su propio handler—, pero la guarda se deja explícita para
+     * que reenrutarlo mañana no reintroduzca el bug.)
      */
     private isTypeaheadKey;
     /** Quita diacríticos y normaliza a minúsculas para comparar etiquetas. */
@@ -2575,13 +2704,14 @@ declare class SelectComponent implements ControlValueAccessor, OnInit, OnDestroy
     private updateMenuWidth;
     private readonly onWindowResize;
     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 ɵ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; }; "creatable": { "alias": "creatable"; "required": false; }; "createPlaceholder": { "alias": "createPlaceholder"; "required": false; }; "createLabel": { "alias": "createLabel"; "required": false; }; "createFactory": { "alias": "createFactory"; "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"; "created": "created"; }, 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_creatable: unknown;
     static ngAcceptInputType_maxVisible: unknown;
     static ngAcceptInputType_showHelpText: unknown;
     static ngAcceptInputType_showIconHelp: unknown;
@@ -3002,5 +3132,1200 @@ declare class DividerComponent implements AfterViewInit {
     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 };
+/** Tratamiento del indicador: punto de color · píldora tonal · píldora neutra. */
+type IusInsigniaVariant = 'dot' | 'count' | 'count-soft';
+/** Familia de color: 6 semánticas + 6 frutas categóricas. */
+type IusInsigniaTone = 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'neutral' | 'durazno' | 'banano' | 'sandia' | 'arandano' | 'uva' | 'aguacate';
+/** Tamaño. */
+type IusInsigniaSize = 'small' | 'medium' | 'large';
+/**
+ * Insignia — Ius Design v2 (familia feedback).
+ *
+ * Indicador atómico de estado o actividad: punto de color (`dot`) o píldora de
+ * contador (`count` tonal · `count-soft` suave), con `label` opcional al lado.
+ * Display puro — sin outputs. Fuente de verdad: `Insignia.jsx` + `Insignia.d.ts`
+ * + `Insignia.ng-spec.md`.
+ *
+ * Para etiqueta con texto contenedor → Tag; para token removible en un campo →
+ * Chip. La consume MenuItem (badge) y la barra de navegación.
+ */
+declare class InsigniaComponent {
+    /** Punto de color · píldora tonal · píldora neutra. */
+    readonly variant: _angular_core.InputSignal<IusInsigniaVariant>;
+    /** Familia de color. */
+    readonly tone: _angular_core.InputSignal<IusInsigniaTone>;
+    /** Tamaño. */
+    readonly size: _angular_core.InputSignal<IusInsigniaSize>;
+    /** Texto junto al indicador (alternativa a proyectar contenido). */
+    readonly label: _angular_core.InputSignal<string | number | undefined>;
+    /** Valor del contador (variantes `count` / `count-soft`). */
+    readonly count: _angular_core.InputSignal<string | number | undefined>;
+    /** Tope antes de mostrar `N+`. */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Halo suave alrededor del punto (solo `dot`). */
+    readonly ring: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Recomendada cuando no hay `label`. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** `count`/`count-soft` renderizan píldora; `dot` renderiza punto. */
+    protected readonly isCount: _angular_core.Signal<boolean>;
+    /** El halo es exclusivo del punto (el golden lo ignora en las píldoras). */
+    protected readonly showRing: _angular_core.Signal<boolean>;
+    /** `count > max` → `${max}+`; los valores string pasan tal cual. */
+    protected readonly displayCount: _angular_core.Signal<string | number | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InsigniaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InsigniaComponent, "ius-insignia", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "ring": { "alias": "ring"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Contexto de uso: fila de overlay (neutral) · fila del NavRail (verde marca). */
+type IusMenuItemVariant = 'menu' | 'rail';
+/** Tamaño de la fila. */
+type IusMenuItemSize = 'small' | 'medium' | 'large';
+/** Estado forzado — **solo demos/especímenes del DS**. */
+type IusMenuItemState = 'hover' | 'pressed';
+/**
+ * Marca contenido libre al final de la fila (chevron, valor, atajo):
+ * `<ius-menu-item><span iusMenuItemTrailing>⌘K</span></ius-menu-item>`.
+ */
+declare class IusMenuItemTrailingDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IusMenuItemTrailingDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IusMenuItemTrailingDirective, "[iusMenuItemTrailing]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * MenuItem — Ius Design v2 (familia navigation).
+ *
+ * Fila de acción o navegación: ícono + etiqueta + badge/trailing. Unidad
+ * compartida por la superficie **Menu** (overlays) y el **NavRail**:
+ * `variant="menu"` es neutral; `variant="rail"` lleva el ícono verde de marca y
+ * el pressed verde sólido sobre blanco (firma del rail). `danger` (rojo) solo
+ * aplica a `menu` — el caso canónico es «Cerrar sesión».
+ *
+ * Con `href` renderiza `<a>`; si no, `<button type="button">`. Por eso el host
+ * es `display: contents`: el elemento real de la fila (y por tanto el foco, el
+ * `:hover` y la semántica) es el `<a>`/`<button>` interno, tal como el golden.
+ *
+ * Fuente de verdad: `MenuItem.jsx` + `MenuItem.d.ts` + `MenuItem.ng-spec.md`.
+ * Compone Insignia para el badge. Para botón con texto → Button; píldora de
+ * valor → Tag/Chip.
+ */
+declare class MenuItemComponent {
+    /** Ícono Material Symbols a la izquierda. */
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    /** Texto de la fila (alternativa a proyectar contenido). */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** `number` → Insignia contador; `true` → punto; `null`/`false` → sin badge. */
+    readonly badge: _angular_core.InputSignal<number | boolean | null | undefined>;
+    /** Contexto de uso (menu neutral · rail verde marca). */
+    readonly variant: _angular_core.InputSignal<IusMenuItemVariant>;
+    /** Tamaño de la fila. */
+    readonly size: _angular_core.InputSignal<IusMenuItemSize>;
+    /** Fondo persistente + `aria-current`. */
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fila inerte. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Acción destructiva (rojo). Solo `variant="menu"`. */
+    readonly danger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Estado forzado — **solo demos**. */
+    readonly state: _angular_core.InputSignal<IusMenuItemState | undefined>;
+    /** Renderiza la fila como `<a href>`. */
+    readonly href: _angular_core.InputSignal<string | undefined>;
+    /** Etiqueta accesible cuando el texto no basta. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Rol ARIA del elemento de fila — Menu lo fija en `menuitem`. */
+    readonly itemRole: _angular_core.InputSignal<string | undefined>;
+    /** Al activar la fila (espejo de `onClick`). */
+    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
+    protected readonly trailingRef: _angular_core.Signal<IusMenuItemTrailingDirective | undefined>;
+    /** El `<a>` solo se usa si hay `href` y la fila no está deshabilitada. */
+    protected readonly isLink: _angular_core.Signal<boolean>;
+    /** `null`/`undefined`/`false` = sin badge (el 0 sí se muestra, como el golden). */
+    protected readonly hasBadge: _angular_core.Signal<boolean>;
+    /** `true` → punto; número → píldora de contador. */
+    protected readonly badgeVariant: _angular_core.Signal<IusInsigniaVariant>;
+    /** El punto del rail es informativo (azul); en menu avisa (rojo). */
+    protected readonly badgeTone: _angular_core.Signal<IusInsigniaTone>;
+    /** Valor del contador (solo cuando el badge es numérico). */
+    protected readonly badgeCount: _angular_core.Signal<number | undefined>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "ius-menu-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "danger": { "alias": "danger"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "itemRole": { "alias": "itemRole"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, ["trailingRef"], ["*", "[iusMenuItemTrailing]"], true, never>;
+}
+/**
+ * Opción de menú — tipo **compartido** por Menu, Dropdown y ContextMenu.
+ *
+ * `trailing` acepta texto plano o un `TemplateRef` (equivalente Angular del
+ * slot/ReactNode del golden, según la regla de port `render` → `TemplateRef`).
+ */
+interface IusMenuOption {
+    /** Valor lógico — el que viaja en `valueChange` y marca el check. */
+    value?: string | number;
+    /** Clave de `@for`; si falta se usa `value` y, en último caso, el índice. */
+    key?: string | number;
+    /** Ícono Material Symbols a la izquierda. */
+    icon?: string;
+    /** Texto de la fila. */
+    label?: string;
+    /** Contenido al final de la fila (atajo, valor, chevron). */
+    trailing?: string | TemplateRef<unknown>;
+    /** Al cambiar de grupo se inserta un divisor. */
+    group?: string | number;
+    /** Divisor explícito (la fila no se renderiza). */
+    separator?: boolean;
+    /** Acción destructiva (rojo). */
+    danger?: boolean;
+    /** Fila inerte. */
+    disabled?: boolean;
+    /** Acción propia de la opción. */
+    onClick?: (event: MouseEvent) => void;
+}
+/** Fila resuelta o divisor — lo que realmente pinta la plantilla. */
+interface IusMenuRow {
+    kind: 'separator' | 'item';
+    key: string;
+    item?: IusMenuOption;
+    selected?: boolean;
+}
+/**
+ * Menu — Ius Design v2 (familia overlays). **SUPERFICIE compartida de menú.**
+ *
+ * Lista de **MenuItem** con encabezado opcional, divisores, grupos, ítems
+ * peligrosos/deshabilitados y modo selección única (check a la derecha). Es el
+ * cuerpo que **Dropdown** ancla a un disparador y **ContextMenu** ancla al
+ * cursor: por sí sola **no se posiciona ni gestiona apertura**.
+ *
+ * Fuente de verdad: `Menu.jsx` + `Menu.d.ts` + `Menu.ng-spec.md`. Las filas se
+ * renderizan con `size="small"` y `variant="menu"`, como el golden.
+ */
+declare class MenuComponent {
+    /** Opciones del menú (tipo compartido con Dropdown/ContextMenu). */
+    readonly items: _angular_core.InputSignal<readonly IusMenuOption[]>;
+    /** Selección única: marca `value` con un check. */
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Valor elegido en modo `selectable`. */
+    readonly value: _angular_core.InputSignal<string | number | undefined>;
+    /** Encabezado visual del menú. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Etiqueta accesible de la superficie. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Modo `selectable` — espejo de `onChange`. */
+    readonly valueChange: _angular_core.OutputEmitterRef<{
+        value: string | number | undefined;
+        item: IusMenuOption;
+    }>;
+    /** Tras activar un ítem — Dropdown/ContextMenu lo usan para cerrar. */
+    readonly itemClick: _angular_core.OutputEmitterRef<{
+        item: IusMenuOption;
+        event: MouseEvent;
+    }>;
+    /**
+     * Aplana `items` a filas pintables insertando los divisores de grupo: al
+     * cambiar `group` respecto de la fila anterior se mete un separador (el
+     * primer ítem nunca lo lleva), y `separator: true` es un divisor explícito.
+     */
+    protected readonly rows: _angular_core.Signal<IusMenuRow[]>;
+    /** `trailing` como TemplateRef (slot rico) — si no, se pinta como texto. */
+    protected trailingTpl(item: IusMenuOption): TemplateRef<unknown> | null;
+    /** `trailing` como texto plano (atajo, valor corto). */
+    protected trailingText(item: IusMenuOption): string | null;
+    protected onItemClick(row: IusMenuRow, event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "ius-menu", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "itemClick": "itemClick"; }, never, never, true, never>;
+}
+/** Familia de color del disparador por defecto. */
+type IusDropdownTone = 'primary' | 'neutral';
+/** Tratamiento del disparador por defecto. */
+type IusDropdownVariant = 'ghost' | 'outline';
+/** Opción del Dropdown — el tipo compartido de Menu/ContextMenu. */
+type IusDropdownItem = IusMenuOption;
+/**
+ * Marca un disparador propio, en lugar del ghost texto+chevron por defecto:
+ * `<ius-dropdown><ius-icon-button iusDropdownTrigger …/></ius-dropdown>`.
+ */
+declare class IusDropdownTriggerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IusDropdownTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IusDropdownTriggerDirective, "[iusDropdownTrigger]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Dropdown — Ius Design v2 (familia overlays).
+ *
+ * Menú desplegable accionable: un disparador abre un **Popover** (sin rabito,
+ * `bottom-start` por defecto) con una superficie **Menu**. Dos modos: **acciones**
+ * (cada ítem ejecuta y cierra) y **selección única** (`selectable`, check en la
+ * activa y la etiqueta elegida en el disparador).
+ *
+ * El disparador por defecto es un botón ghost texto+chevron (el chevron gira al
+ * abrir); `variant="outline"` replica el contenedor del botón de QueryBuilder
+ * (mismo borde/radio/padding/altura) para encajar en barras y SegmentGroup. Con
+ * `[iusDropdownTrigger]` se proyecta un disparador propio.
+ *
+ * No es campo de formulario — eso es **Select**; para una sola acción →
+ * Button/IconButton. Fuente de verdad: `Dropdown.jsx` + `Dropdown.d.ts` +
+ * `Dropdown.ng-spec.md`.
+ */
+declare class DropdownComponent {
+    /** Opciones del menú (mismo shape que `MenuOption`). */
+    readonly items: _angular_core.InputSignal<readonly IusMenuOption[]>;
+    /** Selección única: marca la opción activa con un check. */
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Valor elegido en modo `selectable`. */
+    readonly value: _angular_core.InputSignal<string | number | undefined>;
+    /** Encabezado del menú (y texto del disparador por defecto si no hay elegida). */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Texto del disparador por defecto (gana sobre la opción elegida y `label`). */
+    readonly triggerLabel: _angular_core.InputSignal<string | undefined>;
+    /** Ícono Material Symbols del disparador por defecto. */
+    readonly triggerIcon: _angular_core.InputSignal<string | undefined>;
+    /** Familia de color del disparador por defecto. */
+    readonly tone: _angular_core.InputSignal<IusDropdownTone>;
+    /** Tratamiento del disparador por defecto. */
+    readonly variant: _angular_core.InputSignal<IusDropdownVariant>;
+    /** Colocación del panel respecto del disparador. */
+    readonly placement: _angular_core.InputSignal<IusPopoverPlacement>;
+    /** Modo controlado (`undefined` = no controlado con `defaultOpen`). */
+    readonly open: _angular_core.InputSignal<boolean | undefined>;
+    /** Estado inicial del modo no controlado. */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Etiqueta accesible del disparador por defecto. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Modo `selectable` — espejo de `onChange`. */
+    readonly valueChange: _angular_core.OutputEmitterRef<{
+        value: string | number | undefined;
+        item: IusDropdownItem;
+    }>;
+    /** Apertura/cierre del panel. */
+    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
+    protected readonly customTrigger: _angular_core.Signal<IusDropdownTriggerDirective | undefined>;
+    /** `null` = el usuario todavía no ha abierto/cerrado → manda `defaultOpen`. */
+    private readonly internalOpen;
+    /** Controlado por `open` si viene definido; si no, estado interno. */
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    /** Opción activa en modo `selectable` — alimenta el texto del disparador. */
+    private readonly current;
+    /** `triggerLabel` › etiqueta de la opción elegida › `label`. */
+    protected readonly triggerText: _angular_core.Signal<string | undefined>;
+    /** El encabezado del menú solo aplica en modo selección (como el golden). */
+    protected readonly menuLabel: _angular_core.Signal<string | undefined>;
+    protected onOpenChange(open: boolean): void;
+    protected onValueChange(payload: {
+        value: string | number | undefined;
+        item: IusMenuOption;
+    }): void;
+    /** Activar un ítem cierra el panel (acciones y selección). */
+    protected onItemClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "ius-dropdown", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; "isSignal": true; }; "triggerIcon": { "alias": "triggerIcon"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "openChange": "openChange"; }, ["customTrigger"], ["[iusDropdownTrigger]"], true, never>;
+}
+/** Tono semántico de un estado (nunca un hue "fruta"). */
+type StatusTone = 'info' | 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
+/** Los 6 tonos semánticos, en el orden del contrato. Útil para matrices/demos. */
+declare const STATUS_TONES: readonly StatusTone[];
+/**
+ * Cómo se pinta un estado: rótulo, tono semántico e ícono Material Symbols
+ * (ligadura, p. ej. `check_circle`).
+ */
+interface StatusMeta {
+    /** Rótulo humano del estado. `string` (el golden usa `ReactNode`; ver §1 de la cabecera). */
+    label: string;
+    /** Familia semántica del estado. */
+    tone: StatusTone;
+    /** Ligadura Material Symbols Rounded. */
+    icon: string;
+}
+/**
+ * Mapa de una entidad: `status → StatusMeta`. El **orden de declaración** de las
+ * claves es el orden del ciclo de vida.
+ */
+type StatusVocabMap = Readonly<Record<string, StatusMeta>>;
+/** Opción lista para dropdown / filtro / orden por estado. */
+interface StatusOption {
+    /** Clave del estado (la que viaja al backend). */
+    value: string;
+    /** Rótulo humano. */
+    label: string;
+    /** Familia semántica. */
+    tone: StatusTone;
+    /** Ligadura Material Symbols Rounded. */
+    icon: string;
+}
+/** Par de variables de color de un tono: texto/ícono y punto (marca). */
+interface StatusToneVars {
+    /** Color del texto y del ícono. Siempre un `var(--ius-*)`. */
+    fg: string;
+    /** Color del punto/marca. Siempre un `var(--ius-*)`. */
+    mark: string;
+}
+/**
+ * Catálogo: entidad → `{ status → StatusMeta }`.
+ *
+ * El **orden de declaración** de cada estado es el orden del ciclo. El catálogo
+ * es ABIERTO: se agregan entidades aquí sin tocar `StatusChip` (ver
+ * `STATUS_VOCABS_PENDING`). Un módulo puede además extender en runtime pasando
+ * `customMap` a `resolveStatus`.
+ */
+declare const STATUS_VOCAB: {
+    readonly actuacion: {
+        readonly nueva: {
+            readonly label: "Nueva";
+            readonly tone: "info";
+            readonly icon: "fiber_new";
+        };
+        readonly vista: {
+            readonly label: "Vista";
+            readonly tone: "neutral";
+            readonly icon: "drafts";
+        };
+        readonly gestion: {
+            readonly label: "En gestión";
+            readonly tone: "primary";
+            readonly icon: "pending_actions";
+        };
+        readonly cerrada: {
+            readonly label: "Cerrada";
+            readonly tone: "success";
+            readonly icon: "check_circle";
+        };
+    };
+    readonly gestion: {
+        readonly por_hacer: {
+            readonly label: "Por hacer";
+            readonly tone: "info";
+            readonly icon: "radio_button_unchecked";
+        };
+        readonly en_curso: {
+            readonly label: "En curso";
+            readonly tone: "primary";
+            readonly icon: "pending";
+        };
+        readonly por_vencer: {
+            readonly label: "Por vencer";
+            readonly tone: "warning";
+            readonly icon: "schedule";
+        };
+        readonly vencida: {
+            readonly label: "Vencida";
+            readonly tone: "danger";
+            readonly icon: "event_busy";
+        };
+        readonly hecha: {
+            readonly label: "Hecha";
+            readonly tone: "success";
+            readonly icon: "check_circle";
+        };
+    };
+};
+/** Entidades con vocabulario definido HOY en el catálogo. */
+type StatusVocabName = keyof typeof STATUS_VOCAB;
+/** Estados del vocabulario `actuacion` (validado). */
+type ActuacionStatus = keyof (typeof STATUS_VOCAB)['actuacion'];
+/** Estados del vocabulario `gestion` (propuesto — confirmar con backend). */
+type GestionStatus = keyof (typeof STATUS_VOCAB)['gestion'];
+/** Entidades con vocabulario definido. */
+declare const STATUS_VOCABS: readonly StatusVocabName[];
+/**
+ * Entidades que TIENEN estado pero cuyo vocabulario aún NO está en el catálogo:
+ * sus estados/tonos son decisión humana pendiente con el backend (§6 del
+ * golden). Se listan para documentar el hueco, no para inventarlo. Al validarse
+ * se agregan a `STATUS_VOCAB` y se quitan de aquí; `StatusChip` no se toca.
+ */
+declare const STATUS_VOCABS_PENDING: readonly string[];
+/**
+ * Estados (claves) de una entidad, en orden de ciclo.
+ * `[]` si la entidad no existe.
+ */
+declare function statusOrder(vocab: string): string[];
+/**
+ * Mapa `status → StatusMeta` de una entidad.
+ * `null` si la entidad no está en el catálogo (retorno nullable, a propósito).
+ */
+declare function statusVocab(vocab: string): StatusVocabMap | null;
+/**
+ * Resuelve un estado a `StatusMeta` en este orden:
+ *   1. `customMap[status]` — extensión en runtime del módulo consumidor;
+ *   2. catálogo central de la entidad;
+ *   3. `null` — entidad o estado desconocido: el consumidor decide (el átomo
+ *      `StatusChip` cae a `neutral` con el `status` crudo como rótulo).
+ *
+ * @param vocab Entidad (p. ej. `'actuacion'`).
+ * @param status Clave del estado YA resuelta por el consumidor (la urgencia de
+ *   una tarea se deriva antes de llamar aquí).
+ * @param customMap Vocabulario extra del módulo; gana sobre el catálogo.
+ */
+declare function resolveStatus(vocab: string, status: string | null | undefined, customMap?: Readonly<Record<string, StatusMeta>>): StatusMeta | null;
+/**
+ * Opciones listas para dropdown / filtro / orden de una entidad, en orden de
+ * ciclo. `[]` si la entidad no existe.
+ */
+declare function statusOptions(vocab: string): StatusOption[];
+/**
+ * Tono semántico → `{ fg, mark }` (strings `var(--ius-*)`).
+ * Único punto del sistema que conoce las vars de color del estado.
+ * Un tono desconocido, `null` o `undefined` cae a `neutral` (nunca falla).
+ */
+declare function statusToneVars(tone: StatusTone | null | undefined): StatusToneVars;
+/** Escala de la barra — small ~34 · medium ~40 (default) · large ~48px. */
+type IusSearchBarSize = 'small' | 'medium' | 'large';
+/** Estado forzado — **solo demos/especímenes**. En producción usar `disabled`. */
+type IusSearchBarState = 'hover' | 'focused' | 'disabled';
+/**
+ * SearchBar — Ius Design v2.
+ *
+ * Barra de **búsqueda** (filtrado de tablas, listas y resultados: proceso,
+ * radicado, deudor). Compone: `input[type=search]` + botón circular de limpiar
+ * (slot reservado) + botón de lupa. Tratamiento de color poco intrusivo:
+ * vacía = relleno gris discreto · con criterio = blanco + borde hairline ·
+ * foco = blanco + borde de marca + lupa azul · disabled = gris atenuado.
+ *
+ * **Cuándo NO usarlo:** como campo de formulario con label/validación (eso es
+ * `ius-text-field`), para elegir de una lista cerrada (`ius-select`) o para
+ * filtros estructurados por chips (FilterBar).
+ *
+ * Implementa `ControlValueAccessor` completo (`string`) para `[(ngModel)]` /
+ * `formControl`, y además soporta `[(value)]`.
+ *
+ * Fuente de verdad: `components/inputs/SearchBar/SearchBar.jsx` + `.d.ts` +
+ * `SearchBar.ng-spec.md` + `searchbar.card.html` / `playground.card.html`.
+ *
+ * ── Notas del port a Angular ─────────────────────────────────────────────
+ * - `.ius-sb` (raíz del golden) **es el host**: no hay div envolvente, porque
+ *   uno rompería `:focus-within` y el `role="search"` del contenedor real.
+ * - El botón de limpiar **nunca sale del flujo**: solo alterna `visibility` +
+ *   `pointer-events` (`.ius-sb__clear--hidden`), así aparecer/desaparecer no
+ *   desplaza el input ni la lupa (geometría estable).
+ * - `blur` → `onTouched()` es un añadido del port (el golden React no tiene
+ *   `onBlur`); lo exige el `ControlValueAccessor`.
+ * - Limpiar emite `valueChange('')` además de `cleared` (el golden solo llama
+ *   `onClear`): el CVA obliga a propagar el valor nuevo al modelo. Mismo
+ *   criterio que `ius-text-field`.
+ *
+ * ── Divergencias doc vs golden (manda el golden; para diseño) ────────────
+ * - `searchbar.card.html` §06 lista `--ius-radius-md (8px)` como radio de la
+ *   barra, pero el CSS golden usa `var(--ius-radius-lg)` (14px). Se porta el
+ *   golden.
+ * - `SearchBar.prompt.md` y §06 anuncian **anillo de foco** (`--ius-focus-ring`)
+ *   en la barra enfocada; el CSS golden lo niega explícitamente
+ *   ("sin sombra exterior") y solo aplica el anillo al `:focus-visible` de los
+ *   botones internos. Se porta el golden.
+ * - §02 "Anatomía" numera la lupa como pieza 1 (sugiere lupa a la izquierda),
+ *   pero el golden renderiza `input → limpiar → lupa`, así que la lupa queda a
+ *   la **derecha**. Se porta el golden.
+ */
+declare class SearchBarComponent implements ControlValueAccessor {
+    private readonly valueState;
+    /** Marca si el consumidor ató el valor (input `value`, `[(value)]` o CVA). */
+    private readonly boundValue;
+    /** Criterio de búsqueda (controlado). Habilita `[(value)]`. */
+    set value(value: string | null | undefined);
+    get value(): string;
+    /** Criterio inicial (no controlado). Equivale a `defaultValue` del golden. */
+    set defaultValue(value: string | null | undefined);
+    private readonly sizeState;
+    /** Escala de la barra. Sin valor explícito hereda `--ius-control-size`. */
+    set size(value: IusSearchBarSize);
+    get size(): IusSearchBarSize;
+    /** `disabled` recibido como input del template. */
+    private readonly disabledInput;
+    /** `disabled` impuesto por el formulario (`setDisabledState`). */
+    private readonly disabledByForm;
+    /**
+     * Estado deshabilitado. El efectivo es
+     * `input || setDisabledState() || state === 'disabled'`, así una fuente no
+     * pisa a la otra (un `[disabled]="false"` no reactiva un control que el
+     * formulario deshabilitó, ni al revés).
+     */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    /** Estado visual forzado — **solo demos/especímenes** del DS. */
+    protected readonly stateInput: _angular_core.WritableSignal<IusSearchBarState | undefined>;
+    /**
+     * Fuerza un estado visual (`hover` · `focused` · `disabled`).
+     * **Solo demos/especímenes**: en producción usa `disabled` y deja que el
+     * navegador resuelva hover/foco. Con `hover`/`focused`, la barra vacía y
+     * *sin* valor atado, el golden pinta un criterio de relleno para que se vea
+     * el círculo de limpiar (ver `IUS_SB_DEMO_VALUE`).
+     */
+    set state(value: IusSearchBarState | undefined);
+    get state(): IusSearchBarState | undefined;
+    /** Texto guía dentro del input. Di qué se puede buscar. */
+    placeholder: string;
+    /** Etiqueta accesible del input. */
+    ariaLabel: string;
+    /** `name` del input nativo. */
+    name?: string;
+    /** `id` del input nativo. Si se omite se genera uno estable. */
+    id?: string;
+    /** Cambio de criterio en cada tecla (original `onChange`). Habilita `[(value)]`. */
+    readonly valueChange: EventEmitter<string>;
+    /**
+     * Disparo de búsqueda: Enter o clic en la lupa (original `onSearch`).
+     *
+     * Nota: `input[type=search]` tiene un evento DOM nativo homónimo, pero al
+     * declararse como `@Output` Angular enlaza **solo** este emisor en
+     * `(search)` (no añade listener de DOM), así que no hay doble disparo.
+     */
+    readonly search: EventEmitter<string>;
+    /** Al limpiar con el botón circular (original `onClear`). */
+    readonly cleared: EventEmitter<void>;
+    private readonly inputRef;
+    private readonly autoId;
+    /** Estado forzado que el golden considera "con criterio" (demos). */
+    private readonly demoFilled;
+    /** Disabled efectivo (input + formulario + estado forzado de demo). */
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** ¿Hay criterio? Gobierna `data-filled` y la visibilidad del círculo ×. */
+    protected readonly filled: _angular_core.Signal<boolean>;
+    /** Valor que se pinta en el input (solo difiere del real en demos). */
+    protected readonly displayValue: _angular_core.Signal<string>;
+    protected get inputId(): string;
+    private onChangeFn;
+    private onTouchedFn;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    /** Enter en el input o clic en la lupa. */
+    protected triggerSearch(): void;
+    /** Botón circular ×: limpia, notifica y devuelve el foco al input. */
+    protected clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchBarComponent, "ius-search-bar", never, { "value": { "alias": "value"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "valueChange": "valueChange"; "search": "search"; "cleared": "cleared"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+/** Tamaño del campo — small · medium (default) · large. */
+type IusTextAreaSize = 'small' | 'medium' | 'large';
+/** Estado forzado visualmente — solo demos / especímenes. */
+type IusTextAreaState = 'hover' | 'focused' | 'error' | 'disabled';
+/**
+ * TextArea — Ius Design v2 (familia inputs).
+ *
+ * Variante **multilínea** de TextField para texto largo de redacción libre
+ * (notas de impulso, observaciones de audiencia, descripciones, comentarios).
+ * Reusa el wrapper `.ius-tf` (label + required + iconHelp + 5 estados + `size`
+ * + helpText/errorText) y **crece con el contenido** desde `rows` hasta
+ * `maxRows`, tras lo cual hace scroll interno. Implementa
+ * `ControlValueAccessor` completo (`[(ngModel)]` / `formControl`) con `string`
+ * como valor.
+ *
+ * Compone `ius-popover` para la pastilla «?» (`showIconHelp`), igual que
+ * TextField.
+ *
+ * **Cuándo NO usarlo**: una sola línea → `ius-text-field`; datos segmentados →
+ * `ius-multi-text-field`; códigos OTP → `ius-code-field`.
+ *
+ * Fuente de verdad: `components/inputs/TextArea/TextArea.jsx` + `TextArea.d.ts`
+ * (delta sobre `TextField.ng-spec.md`) del proyecto Claude Design.
+ *
+ * ---
+ * **Divergencias doc-vs-golden** (manda el `.jsx` golden; quedan anotadas para
+ * que diseño las resuelva):
+ *
+ * 1. **Scrollbar.** `TextArea.ng-spec.md` dice «luego scroll interno con
+ *    `.ius-scroll`»; el CSS golden **no** usa `.ius-scroll`: pinta su propio
+ *    scrollbar en el `<textarea>` (`::-webkit-scrollbar` de 6px, pulgar
+ *    `--ius-neutral-5` con radio pill, `scrollbar-width: thin`). Se portó el
+ *    golden.
+ * 2. **`resizable`.** El `.d.ts` y el `.prompt.md` hablan del «control nativo
+ *    de arrastre (esquina inferior derecha)»; el golden desactiva el grip
+ *    nativo (`resize: none`) y dibuja una **manija propia** `.ius-tf__resize`
+ *    (ícono `drag_handle` rotado −45°, arrastre por pointer events, solo
+ *    vertical). Se portó el golden.
+ * 3. **Tokens.** El panel «Tokens que consume» de `textarea.card.html` cita
+ *    `--ius-neutral-white` y `--ius-stroke` para fondo/borde; el CSS golden
+ *    hereda de `.ius-tf`: fondo `--ius-neutral-2` y borde `transparent` en
+ *    reposo. Se portó el golden.
+ * 4. **`id` / `className` / `style`** del `.d.ts` no se exponen: el host ya es
+ *    el elemento estilable y el `id` del `<textarea>` se genera para enlazar el
+ *    `<label for>` (mismo criterio que `ius-text-field`).
+ *
+ * Nota de implementación: las clases `.ius-tf__*` (label/help/hint/field) se
+ * **replican** en este SCSS porque bajo `ViewEncapsulation.Emulated` las de
+ * TextField no alcanzan a otro componente — mismo precedente que
+ * `ius-multi-text-field` y `ius-code-field`.
+ */
+declare class TextAreaComponent implements ControlValueAccessor {
+    private readonly zone;
+    /** Label sobre el campo (se pinta con `:` final). Sin label si se omite. */
+    label?: string;
+    /** Placeholder dentro del área de texto. */
+    placeholder?: string;
+    /** Punto rojo (•) a la izquierda del label. */
+    required: 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 (compone `ius-popover` en hover/foco). */
+    showIconHelp: boolean;
+    /** Título del contenido de ayuda (popover). */
+    iconHelpTitle?: string;
+    /** Cuerpo del contenido de ayuda (popover). */
+    iconHelpContent?: string;
+    /** `name` del `<textarea>` (envío como formulario nativo). */
+    name?: string;
+    protected readonly rowsState: _angular_core.WritableSignal<number>;
+    /** Líneas mínimas visibles. Default `3`. */
+    set rows(value: number | string | null | undefined);
+    get rows(): number;
+    private readonly maxRowsState;
+    /** Tope de líneas antes de hacer scroll interno. Sin tope si se omite. */
+    set maxRows(value: number | string | null | undefined);
+    get maxRows(): number | undefined;
+    protected readonly autoGrowState: _angular_core.WritableSignal<boolean>;
+    /**
+     * Crecer con el contenido entre `rows` y `maxRows`. Default `true`.
+     * Con `false` la altura queda fija en `rows`. `resizable` lo anula.
+     */
+    set autoGrow(value: boolean);
+    get autoGrow(): boolean;
+    protected readonly resizableState: _angular_core.WritableSignal<boolean>;
+    /**
+     * Permitir redimensionar a mano arrastrando la manija inferior derecha.
+     * **Excluyente con `autoGrow`** (al activarlo, el auto-crecimiento se apaga).
+     * Default `false`.
+     */
+    set resizable(value: boolean);
+    get resizable(): boolean;
+    protected readonly maxLengthState: _angular_core.WritableSignal<number | undefined>;
+    /** Límite de caracteres (`maxlength` nativo). */
+    set maxLength(value: number | string | null | undefined);
+    get maxLength(): number | undefined;
+    /** Mostrar el contador `n / max` bajo el campo (requiere `maxLength`). */
+    showCount: boolean;
+    private readonly errorState;
+    /** Estado de error (colores + `errorText`). */
+    set error(value: boolean);
+    get error(): boolean;
+    private readonly disabledState;
+    /** Estado deshabilitado (también lo escribe el CVA vía `setDisabledState`). */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    protected readonly sizeState: _angular_core.WritableSignal<IusTextAreaSize>;
+    /** Tamaño: `small` · `medium` (default) · `large`. */
+    set size(value: IusTextAreaSize);
+    get size(): IusTextAreaSize;
+    protected readonly stateState: _angular_core.WritableSignal<IusTextAreaState | undefined>;
+    /**
+     * Forzar visualmente un estado completo. **Solo demos / especímenes** — no
+     * usar en producción: no altera la interacción real, solo la piel.
+     */
+    set state(value: IusTextAreaState | undefined);
+    get state(): IusTextAreaState | undefined;
+    /** Además del CVA: notifica cada cambio de valor del `<textarea>`. */
+    readonly valueChange: EventEmitter<string>;
+    protected readonly value: _angular_core.WritableSignal<string>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly areaId: string;
+    protected readonly helpId: string;
+    private readonly area;
+    private onChange;
+    private onTouched;
+    /** Cancela los listeners del arrastre en curso (no-op si no hay ninguno). */
+    private stopResize;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly isFocused: _angular_core.Signal<boolean>;
+    protected get hint(): string | undefined;
+    protected get showHint(): boolean;
+    /** Texto del contador `n / max`, o `null` si no aplica. */
+    protected get count(): string | null;
+    /** `min-height` inline del golden cuando la altura se arrastra a mano. */
+    protected get resizableMinHeight(): string | null;
+    constructor();
+    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;
+    /**
+     * Arrastre vertical de la manija (`.ius-tf__resize`). Port del `startResize`
+     * golden: los listeners viven en `window` y se registran fuera de la zona
+     * para no disparar change detection en cada `pointermove`.
+     */
+    protected startResize(event: PointerEvent): void;
+    /**
+     * Ajusta la altura al contenido entre `rows` y `maxRows` (port literal del
+     * `adjust()` golden). Se desactiva con `autoGrow=false` o `resizable=true`,
+     * casos en que la altura la fija el atributo `rows` / el arrastre.
+     */
+    private adjust;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextAreaComponent, "ius-text-area", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "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; }; "name": { "alias": "name"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "maxRows": { "alias": "maxRows"; "required": false; }; "autoGrow": { "alias": "autoGrow"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "showCount": { "alias": "showCount"; "required": false; }; "error": { "alias": "error"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_showHelpText: unknown;
+    static ngAcceptInputType_showIconHelp: unknown;
+    static ngAcceptInputType_autoGrow: unknown;
+    static ngAcceptInputType_resizable: unknown;
+    static ngAcceptInputType_showCount: unknown;
+    static ngAcceptInputType_error: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+/**
+ * Tono semántico del estado. ALIAS de `StatusTone` (foundation
+ * `status-catalog`): el vocabulario NO se re-declara aquí, solo se le pone el
+ * nombre `Ius*` que usa el resto de la librería.
+ */
+type IusStatusChipTone = StatusTone;
+/** Escala tipográfica del chip: `small` = `--ius-fs-sm` · `medium` = `--ius-fs-base`. */
+type IusStatusChipSize = 'small' | 'medium';
+/**
+ * StatusChip — Ius Design v2 (familia data-display).
+ *
+ * **Átomo visual de estado**: marca semántica (punto de 8px, o ícono) + el
+ * rótulo EN EL COLOR DEL TONO, **sin píldora**. Es el patrón reconocible de
+ * "estado", reusable por cualquier entidad del sistema (actuación, tarea,
+ * factura, plan, usuario…). No es interactivo: no tiene outputs, ni foco, ni
+ * máquina de estado.
+ *
+ * **QUÉ COMPONE.** Nada visual: es una hoja. Lo que SÍ consume es la foundation
+ * `status-catalog` (`resolveStatus`), donde vive el **vocabulario** — qué
+ * estados existen por entidad y con qué `label · tone · icon`. El átomo solo
+ * pinta: se le pasa `vocab` + `status` y resuelve; o se le pasan
+ * `tone`/`label`/`icon` directo (escape hatch genérico). `vocab` por defecto =
+ * `actuacion` (ciclo `nueva → vista → gestion → cerrada`). La actuación **no
+ * vence**: el vencimiento es estado de sus TAREAS (`vocab="gestion"`), por eso
+ * `gestion` de actuación es `primary` y no `warning`.
+ *
+ * **Resolución (orden del golden).**
+ *  - `meta   = resolveStatus(vocab, status, customMap)`
+ *  - `tono   = tone || meta?.tone || 'neutral'`
+ *  - `rótulo = <ng-content> › label › meta?.label › status crudo`
+ *  - `glifo  = icon===true ? meta?.icon : (string ? ese glifo : ninguno → punto)`
+ *
+ * Un `vocab`/`status` **desconocido nunca falla**: `meta` queda `null` y el chip
+ * cae a `neutral` con el `status` crudo como rótulo.
+ *
+ * **CUÁNDO NO USARLO.**
+ *  - Etiqueta / categoría / filtro (píldora con fondo) → `ius-tag`.
+ *  - Punto o contador atómico SIN texto → `ius-insignia`.
+ *  - Página completa de error/vacío (404, 500) → `ius-status-state`.
+ *  - Token de un evento de agenda con hora → `EventPill` (aún no portado).
+ *  - Un color de IDENTIDAD/categoría (hue "fruta") → `CategoryPalette`: esto es
+ *    ESTADO, y el estado siempre es una familia semántica.
+ *
+ * **A11y.** El host lleva `role="status"`; la marca (punto/ícono) es
+ * `aria-hidden="true"` porque el color NO puede ser el único canal de
+ * información: el rótulo textual es quien comunica el estado.
+ *
+ * `id` / `class` / `style` son passthrough natural del host de Angular: no hay
+ * inputs para ellos.
+ *
+ * FUENTE DE VERDAD. Proyecto Claude Design →
+ * `components/data-display/StatusChip/StatusChip.jsx` + `.d.ts` + `.ng-spec.md`
+ * + `statuschip.card.html` + `playground.card.html`.
+ *
+ * DIVERGENCIAS / DECISIONES DE PORT (para que diseño las resuelva):
+ *  1. `label` es `string` (el golden lo tipa `ReactNode`). Regla 5 del port. Si
+ *     hace falta contenido rico se PROYECTA (`<ng-content>`), que gana sobre
+ *     `label`.
+ *  2. `icon` como **atributo sin valor** (`<ius-status-chip icon>`) llega como
+ *     `''`, no como `true`: se interpreta como `true` (ícono del catálogo), que
+ *     es la traducción fiel del `<StatusChip icon />` de React. También se
+ *     aceptan los strings `'true'` / `'false'`. Un string no vacío distinto de
+ *     esos dos es el glifo Material Symbols. NO se usa `booleanAttribute`:
+ *     destruiría el caso string.
+ *  3. `data-size` se omite cuando vale el default (`small`), igual que `ius-tag`
+ *     e `ius-insignia`; el golden lo emite siempre. Es equivalente visualmente
+ *     (el bloque base del CSS ES el de `small`), pero el DOM difiere.
+ *  4. El golden no expone `aria-label`; se confía en el rótulo textual. Si un
+ *     consumidor necesitara un rótulo accesible distinto del visible, lo pone
+ *     él sobre el host (passthrough).
+ */
+declare class StatusChipComponent implements AfterViewInit {
+    /**
+     * Entidad cuyo vocabulario (en `status-catalog`) resuelve el `status`.
+     * Default `'actuacion'`. Una entidad fuera del catálogo no falla: el chip cae
+     * a `neutral`.
+     */
+    readonly vocab: _angular_core.InputSignal<string>;
+    /**
+     * Clave del estado DENTRO del `vocab` (p. ej. `'gestion'`). Resuelve rótulo +
+     * tono + ícono. La urgencia de una tarea (`por_vencer`/`vencida`) se DERIVA de
+     * la fecha límite en el consumidor ANTES de llegar aquí.
+     */
+    readonly status: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Fuerza el tono y sobrescribe el del catálogo. Escape hatch genérico para
+     * estados que todavía no tienen vocabulario.
+     */
+    readonly tone: _angular_core.InputSignal<StatusTone | undefined>;
+    /**
+     * Sobrescribe el rótulo. Alternativa a proyectar contenido; si hay
+     * `<ng-content>`, la proyección GANA. Si no resuelve nada, se muestra el
+     * `status` crudo.
+     */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Marca del chip. `false`/ausente → punto de 8px (default). `true` (o el
+     * atributo sin valor `icon`) → ícono del estado tomado del catálogo. Un string
+     * no vacío → ese glifo Material Symbols Rounded (p. ej. `'event_busy'`).
+     * Es `boolean | string` a propósito: no lleva `booleanAttribute`.
+     */
+    readonly icon: _angular_core.InputSignal<string | boolean | undefined>;
+    /** Escala tipográfica: `small` (`fs-sm`, default) · `medium` (`fs-base`). */
+    readonly size: _angular_core.InputSignal<IusStatusChipSize>;
+    /**
+     * Extiende / sobrescribe el vocabulario EN RUNTIME (`status → StatusMeta`).
+     * Gana sobre el catálogo central. Si un estado pasado por aquí se vuelve
+     * común, se PROMUEVE a `status-catalog`.
+     */
+    readonly customMap: _angular_core.InputSignal<Readonly<Record<string, StatusMeta>> | undefined>;
+    /**
+     * Retro-compat con el estático `StatusChip.states` del golden: alias al
+     * vocabulario `actuacion` del catálogo. NO re-declara nada; es la misma
+     * referencia que `STATUS_VOCAB.actuacion`.
+     */
+    static readonly states: StatusVocabMap;
+    /**
+     * Retro-compat con el estático `StatusChip.order` del golden: claves de
+     * `actuacion` en orden de ciclo, leídas del catálogo con `statusOrder`.
+     */
+    static readonly order: readonly ActuacionStatus[];
+    /**
+     * Span donde se estampa `<ng-content>`. Se inspecciona UNA sola vez para saber
+     * si el consumidor proyectó rótulo (patrón de `ius-divider`: bajo OnPush
+     * `<ng-content>` no se re-evalúa, así que no hay forma reactiva de saberlo).
+     */
+    private proyeccionRef;
+    /** `true` si el consumidor proyectó contenido no vacío. */
+    protected readonly hayProyeccion: _angular_core.WritableSignal<boolean>;
+    /** Entrada del catálogo, o `null` si el `vocab`/`status` no se reconoce. */
+    protected readonly meta: _angular_core.Signal<StatusMeta | null>;
+    /**
+     * Tono aplicado: `tone` explícito › tono del catálogo › `neutral`.
+     * Se usa `||` (no `??`) para calcar el fallback del golden.
+     */
+    protected readonly tonoEfectivo: _angular_core.Signal<StatusTone>;
+    /**
+     * Rótulo cuando NO hay proyección: `label` › `meta.label` › `status` crudo.
+     * Se usa `??` porque el golden compara con `!= null`: un `label=""` explícito
+     * es un override válido a cadena vacía.
+     */
+    protected readonly rotulo: _angular_core.Signal<string>;
+    /**
+     * Glifo Material Symbols a pintar en lugar del punto, o `null` para el punto.
+     * Se parsea a mano porque `icon` es `boolean | string`: cualquier transform
+     * booleano destruiría el caso "glifo arbitrario".
+     */
+    protected readonly glifo: _angular_core.Signal<string | null>;
+    /** Detección única de proyección (igual que `ius-divider`). */
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusChipComponent, "ius-status-chip", never, { "vocab": { "alias": "vocab"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "customMap": { "alias": "customMap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Tipo del campo → fija los operadores y el control de valor. */
+type IusFilterFieldType = 'text' | 'enum' | 'number' | 'date';
+/** Escala de los controles del panel. */
+type IusQueryBuilderSize = 'small' | 'medium';
+/** Valor escalar de una regla (el golden nunca castea a número). */
+type IusFilterValue = string | number;
+/** Opción de un campo `type: 'enum'`. */
+interface IusFilterFieldOption {
+    /** Valor único que viaja en la regla. */
+    value: IusFilterValue;
+    /**
+     * Etiqueta visible. En el golden es `ReactNode`; en Angular se degrada a
+     * `string` (regla 5 del port: un ReactNode dentro de un objeto de datos
+     * baja a texto plano).
+     */
+    label: string;
+}
+/** Campo filtrable: define los operadores disponibles y el control de valor. */
+interface IusFilterField {
+    /** Clave del campo (lo que viaja en `IusFilterRule.field`). */
+    value: string;
+    /**
+     * Etiqueta visible en el selector de campo. `ReactNode` en el golden →
+     * `string` aquí (regla 5 del port).
+     */
+    label: string;
+    /** Tipo del campo. Default `text`. */
+    type?: IusFilterFieldType;
+    /**
+     * Ícono Material Symbols del campo. **Reservado**: el selector de campo no
+     * lo muestra (el golden lo omite a propósito para no meter ruido en el
+     * menú). Se conserva en el contrato por paridad con `FilterField.icon`.
+     */
+    icon?: string;
+    /** Opciones para `type: 'enum'`. */
+    options?: IusFilterFieldOption[];
+    /** Placeholder del control de valor (solo `text` / `number`). */
+    placeholder?: string;
+}
+/** Regla aplicada: campo · operador · valor. Combinación siempre Y (AND). */
+interface IusFilterRule {
+    /** Clave del campo (`IusFilterField.value`). */
+    field: string;
+    /** Clave del operador (ver `IUS_FILTER_OPERATORS`). */
+    operator: string;
+    /** Valor del criterio. */
+    value: IusFilterValue;
+}
+/**
+ * Operadores contextuales por tipo de campo — espejo literal de `OPERATORS`
+ * del golden. El primero de cada lista es el default al elegir el campo.
+ * Se exporta para que el consumidor pueda pintar las reglas aplicadas (chips,
+ * resumen…) con la misma etiqueta que usa el panel.
+ */
+declare const IUS_FILTER_OPERATORS: Readonly<Record<IusFilterFieldType, SelectOption[]>>;
+/**
+ * Fila del borrador. `id` es un **contador incremental de módulo** (el `RID`
+ * del golden): es la identidad que usa el `track` del `@for`. Nunca se traquea
+ * por índice — al quitar una fila intermedia Angular reciclaría los
+ * `ius-select`/`ius-text-field` y los valores se cruzarían entre filas.
+ */
+interface DraftRow {
+    id: number;
+    field: string;
+    operator: string;
+    value: IusFilterValue;
+}
+/**
+ * QueryBuilder — Ius Design v2 (familia navigation).
+ *
+ * Constructor de **filtros secundarios estructurados** (estilo Linear/Vercel):
+ * un botón "Filtros" con contador abre un **Popover** con **filas de criterio**
+ * —campo · operador · valor · quitar— más un footer "Añadir filtro · Limpiar
+ * todo · Aplicar", y un estado vacío.
+ *
+ * Decisiones de UX fijas (vienen del golden, no son configurables):
+ * - **Operadores contextuales** por tipo de campo (text → Contiene/Es igual/No
+ *   contiene · enum → Es/No es · number → Igual/≥/≤ · date → Entre/Antes/Después).
+ * - **Staged**: el panel arma un *borrador* y solo confirma al pulsar "Aplicar"
+ *   (nunca filtra en vivo). Al abrir, el borrador se re-siembra desde lo aplicado.
+ * - **Solo Y (AND)** y **un criterio por campo**: los campos ya usados se
+ *   deshabilitan en el selector y al cubrirlos todos se apaga "Añadir filtro".
+ *
+ * Compone (no reimplementa) `ius-popover`, `ius-select`, `ius-text-field`,
+ * `ius-icon-button`, `ius-button` y `ius-text-button`.
+ *
+ * **Cuándo NO usarlo**: filtro primario rápido por chips → `FilterBar`; rango
+ * de fechas → control dedicado con DatePicker; búsqueda libre → `SearchBar`;
+ * captura de datos → un formulario.
+ *
+ * Fuente de verdad: `components/navigation/QueryBuilder/QueryBuilder.jsx` +
+ * `QueryBuilder.d.ts` + `QueryBuilder.ng-spec.md` del proyecto Claude Design.
+ *
+ * ---
+ * **Divergencias doc-vs-golden anotadas** (manda el golden, diseño decide):
+ * 1. `applyLabel` NO es el texto del botón de confirmar en el caso general: el
+ *    golden lo calcula («Aplicar N filtro/filtros» con reglas válidas; «Quitar
+ *    filtros» si no hay ninguna válida pero sí aplicadas) y solo cae a
+ *    `applyLabel` cuando el borrador y lo aplicado están vacíos. La ng-spec lo
+ *    presenta como una etiqueta llana.
+ * 2. Los textos "y" (conjunción), "Selecciona un valor", "Escribe un valor" /
+ *    "Escribe un número" y "Quitar filtro" están **fijos en el golden**: no hay
+ *    input para traducirlos. Si diseño los quiere configurables, primero
+ *    cambia el golden.
+ * 3. El campo `type: 'number'` usa un TextField de texto plano (el golden no
+ *    pasa `type="number"`), así que el valor viaja siempre como `string`.
+ * 4. `FilterField.icon` está en el contrato pero el golden **no lo pinta**.
+ *
+ * **Decisiones del port a Angular**:
+ * - El Popover se usa en modo controlado (`[open]` + `(openChange)`) y **sin**
+ *   `dismissable`, igual que el golden (que tampoco lo activa). Además, aquí es
+ *   obligatorio: el menú del `ius-select` vive en OTRO overlay del CDK, así que
+ *   `outsidePointerEvents()` del Popover lo leería como "clic fuera" y cerraría
+ *   el panel al elegir cualquier opción. El panel se cierra con el propio botón
+ *   "Filtros" o con "Aplicar".
+ * - El ancho/padding del panel (`popoverStyle` del golden) se porta como la
+ *   piel `.ius-popover.ius-querybuilder-pop` en `popover/popover.component.scss`
+ *   (mismo patrón que `.ius-tooltip` y `.ius-dropdown-pop`): el panel se estampa
+ *   desde el template del Popover y lleva SU encapsulación.
+ * - El valor de texto se escribe con `[ngModel]` porque `TextFieldComponent`
+ *   expone su valor solo por `ControlValueAccessor`. Hace falta para poder
+ *   **vaciar** el control cuando cambia el campo de la fila.
+ */
+declare class QueryBuilderComponent {
+    /** Campos filtrables: definen los operadores y el control de valor. */
+    readonly fields: _angular_core.InputSignal<readonly IusFilterField[]>;
+    /**
+     * Reglas aplicadas — **modo controlado**. Si se enlaza, el componente no
+     * guarda estado propio: hay que reaccionar a `apply` y volver a enlazar.
+     */
+    readonly value: _angular_core.InputSignal<readonly IusFilterRule[] | undefined>;
+    /** Reglas iniciales del modo **no controlado**. */
+    readonly defaultValue: _angular_core.InputSignal<readonly IusFilterRule[] | undefined>;
+    /** Texto del botón disparador. */
+    readonly triggerLabel: _angular_core.InputSignal<string>;
+    /** Colocación del panel respecto del disparador. */
+    readonly placement: _angular_core.InputSignal<IusPopoverPlacement>;
+    /** Escala de los controles del panel (se propaga a Select/TextField/botones). */
+    readonly size: _angular_core.InputSignal<IusQueryBuilderSize>;
+    /**
+     * Máximo de filas. Default = `fields.length` (un criterio por campo: no se
+     * repite campo y al cubrirlos todos se desactiva "Añadir filtro"). Fíjalo
+     * solo para un tope distinto.
+     */
+    readonly maxRows: _angular_core.InputSignal<number | undefined>;
+    /** Etiqueta del botón que añade una fila. */
+    readonly addLabel: _angular_core.InputSignal<string>;
+    /** Etiqueta del botón que vacía el borrador. */
+    readonly clearLabel: _angular_core.InputSignal<string>;
+    /**
+     * Etiqueta del botón de confirmar **solo cuando no hay nada que aplicar ni
+     * aplicado**. Ver la divergencia 1 del comentario de cabecera.
+     */
+    readonly applyLabel: _angular_core.InputSignal<string>;
+    /** Título del estado vacío del panel. */
+    readonly emptyTitle: _angular_core.InputSignal<string>;
+    /** Pista del estado vacío del panel. */
+    readonly emptyHint: _angular_core.InputSignal<string>;
+    /**
+     * Reglas válidas al pulsar "Aplicar" (espejo de `onApply`). Nombre fijado
+     * por la ng-spec; no colisiona con ningún evento del DOM.
+     */
+    readonly apply: _angular_core.OutputEmitterRef<IusFilterRule[]>;
+    /** `null` = todavía no se ha aplicado nada → manda `defaultValue`. */
+    private readonly internalApplied;
+    /** Apertura del panel (el Popover se usa en modo controlado). */
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** Borrador del panel: lo que se está armando, aún sin aplicar. */
+    protected readonly draft: _angular_core.WritableSignal<readonly DraftRow[]>;
+    /** Reglas efectivamente aplicadas (controlado › interno › `defaultValue`). */
+    protected readonly applied: _angular_core.Signal<readonly IusFilterRule[]>;
+    /** Contador del disparador. */
+    protected readonly count: _angular_core.Signal<number>;
+    /** Índice campo → definición, para resolver tipo/opciones sin recorrer. */
+    private readonly fieldIndex;
+    /**
+     * Opciones del selector de campo, por fila: un campo ya usado en OTRA fila
+     * se deshabilita (un criterio por campo). Memorizado para no crear arrays
+     * nuevos en cada ciclo de detección (dispararía el setter de `ius-select`).
+     */
+    protected readonly fieldOptions: _angular_core.Signal<Record<number, SelectOption[]>>;
+    /** Opciones del control de valor para los campos `enum`, por campo. */
+    protected readonly enumOptions: _angular_core.Signal<Record<string, SelectOption[]>>;
+    /** Tope efectivo de filas. */
+    protected readonly maxRowsEff: _angular_core.Signal<number>;
+    /** Ya no caben más filas → "Añadir filtro" apagado. */
+    protected readonly atCap: _angular_core.Signal<boolean>;
+    /** Filas del borrador con valor utilizable. */
+    protected readonly validCount: _angular_core.Signal<number>;
+    /** Texto del botón de confirmar (lógica del golden; ver divergencia 1). */
+    protected readonly applyText: _angular_core.Signal<string>;
+    /** Sin nada que aplicar y sin nada aplicado → no hay acción posible. */
+    protected readonly applyDisabled: _angular_core.Signal<boolean>;
+    /** El selector de campo se vuelve buscable con listas largas (golden: `> 6`). */
+    protected readonly fieldsSearchable: _angular_core.Signal<boolean>;
+    /** Tipo del campo (default `text`, como el golden). */
+    protected typeOf(fieldValue: string): IusFilterFieldType;
+    /** Operadores contextuales del campo — referencia estable por tipo. */
+    protected operatorOptions(fieldValue: string): SelectOption[];
+    /** Opciones del selector de campo de una fila (referencia memorizada). */
+    protected fieldOptionsFor(rid: number): SelectOption[];
+    /** Opciones del valor `enum` de un campo. */
+    protected valueOptions(fieldValue: string): SelectOption[];
+    /** El valor `enum` también se vuelve buscable con listas largas (golden: > 6). */
+    protected valueSearchable(fieldValue: string): boolean;
+    /** Placeholder del control de texto (golden: el del campo o uno por tipo). */
+    protected valuePlaceholder(fieldValue: string): string;
+    /** Valor para el `ius-select` de `enum`: `''` → `null` (muestra placeholder). */
+    protected selectValue(value: IusFilterValue): IusSelectValue | null;
+    /** Valor para el `ius-text-field` (siempre `string`). */
+    protected textValue(value: IusFilterValue): string;
+    /**
+     * Al **abrir**, el borrador se re-siembra desde las reglas aplicadas (espejo
+     * del `useEffect([open])` del golden): lo que se dejó a medias sin aplicar se
+     * descarta.
+     */
+    protected onOpenChange(open: boolean): void;
+    /** Crea una fila nueva (espejo de `mkRow`). */
+    private mkRow;
+    /** Parche inmutable de una fila por `id`. */
+    private patch;
+    /** Cambiar el campo resetea operador (al default del tipo) y valor. */
+    protected onFieldChange(rid: number, next: IusSelectValue | IusSelectValue[] | null): void;
+    /** Cambio de operador. */
+    protected onOperatorChange(rid: number, next: IusSelectValue | IusSelectValue[] | null): void;
+    /** Cambio del valor `enum`. */
+    protected onValueChange(rid: number, next: IusSelectValue | IusSelectValue[] | null): void;
+    /** Cambio del valor de texto/número (incluye el botón de limpiar). */
+    protected onTextValueChange(rid: number, next: string): void;
+    /** Normaliza la salida del `ius-select` (single) a escalar. */
+    private scalar;
+    /** Añade una fila con el primer campo libre (respetando `maxRows`). */
+    protected addRow(): void;
+    /** Quita una fila por su `id` (nunca por índice). */
+    protected removeRow(rid: number): void;
+    /** Vacía el borrador (todavía no aplica nada: hay que confirmar). */
+    protected clearAll(): void;
+    /** Confirma el borrador: emite las reglas válidas y cierra el panel. */
+    protected applyDraft(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryBuilderComponent, "ius-query-builder", never, { "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; "addLabel": { "alias": "addLabel"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "applyLabel": { "alias": "applyLabel"; "required": false; "isSignal": true; }; "emptyTitle": { "alias": "emptyTitle"; "required": false; "isSignal": true; }; "emptyHint": { "alias": "emptyHint"; "required": false; "isSignal": true; }; }, { "apply": "apply"; }, never, never, true, never>;
+}
+/**
+ * SegmentGroup — Ius Design v2 (familia layout).
+ *
+ * Agrupa **dos o más controles tipo píldora** ya existentes (`ius-button`
+ * `variant="outline"`, `ius-dropdown` `variant="outline"`, el disparador de
+ * `ius-query-builder`…) en un **bloque segmentado**: el grupo aporta el ÚNICO
+ * shell (borde 1px + radio), los controles internos pierden borde/radio/fondo
+ * propios, el borde compartido se convierte en un **divisor de 1px** y las
+ * esquinas redondeadas quedan solo en el exterior (izquierdas del primero,
+ * derechas del último). Es puramente visual: **cada hijo conserva su propio
+ * clic, su propio menú y su propio estado**; el grupo no tiene outputs.
+ *
+ * Compone: nada. Solo proyecta (`<ng-content>`) y re-estiliza a sus hijos.
+ *
+ * **Cuándo NO usarlo**
+ * - Elegir UNA opción entre varias → `ius-segmented-control` (eso sí es un
+ *   input con selección única).
+ * - Una acción primaria suelta → `ius-button` a secas.
+ * - Barra de filtros de chips removibles → FilterBar/`ius-chip`.
+ *
+ * **Requisito de los hijos.** Todos con tratamiento outline y la misma altura.
+ * OJO: en esta librería `ius-button variant="outline"` es el outline VERDE
+ * (`--ius-success-*`, port verbatim de `Button.jsx`) y es más alto que los
+ * disparadores outline de Dropdown/QueryBuilder (padding `sm lg` vs `xs sm`).
+ * El grupo estira a todos al alto del más alto, pero el color del texto del
+ * Button sigue siendo el suyo. La `SegmentGroup.prompt.md` describe el outline
+ * como «borde 1px stroke + radio md», que es el de Dropdown/QueryBuilder, no el
+ * del Button: divergencia de diseño a resolver por diseño, no por el port.
+ *
+ * **Divergencias doc-vs-golden** (manda el `.jsx`, según regla del repo):
+ * - `segmentgroup.card.html` (panel «Tokens que consume») cita
+ *   `--ius-surface-card` para el fondo y `--ius-radius-lg` (14px) para las
+ *   esquinas. `SegmentGroup.jsx` usa `--ius-neutral-white` y
+ *   `--ius-radius-md` (8px). Se portó el JSX. El fondo es equivalente
+ *   (`--ius-surface-card` → `--ius-neutral-white`), pero el radio SÍ difiere:
+ *   8px reales frente a 14px documentados. Pendiente de que diseño elija.
+ *
+ * Fuente de verdad: `components/layout/SegmentGroup/SegmentGroup.jsx` +
+ * `SegmentGroup.d.ts` + `SegmentGroup.ng-spec.md` (proyecto Claude Design).
+ *
+ * @example
+ * ```html
+ * <ius-segment-group ariaLabel="Filtros de la lista">
+ *   <ius-dropdown variant="outline" triggerIcon="calendar_month"
+ *                 triggerLabel="Últimos 30 días" [items]="rangos" selectable />
+ *   <ius-query-builder [fields]="campos" (apply)="aplicar($event)" />
+ * </ius-segment-group>
+ * ```
+ */
+declare class SegmentGroupComponent {
+    /**
+     * Etiqueta accesible del grupo — se emite como `aria-label` sobre el
+     * `role="group"` del host. Sin ella el grupo queda sin nombre accesible:
+     * decláralo siempre que el conjunto tenga un significado propio
+     * («Herramientas de la lista», «Filtros»…).
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentGroupComponent, "ius-segment-group", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export { AlertComponent, AvatarComponent, ButtonComponent, CaptchaFieldComponent, CarouselComponent, CheckboxComponent, ChipComponent, CircularProgressComponent, CodeFieldComponent, CountdownComponent, CountdownRingComponent, DescriptionListComponent, DividerComponent, DropdownComponent, EleniaBubbleComponent, EleniaOrbComponent, EmptyStateComponent, FlexComponent, HeaderBarComponent, ILLUSTRATIONS, ILLUSTRATION_ALIAS, ILLUSTRATION_NAMES, IUS_FILTER_OPERATORS, IconButtonComponent, IllustrationComponent, InsigniaComponent, IusAlertActionsDirective, IusAlertTrailingDirective, IusDropdownTriggerDirective, IusMenuItemTrailingDirective, IusModalFooterDirective, IusTagPrefixDirective, IusTagSuffixDirective, LoadingComponent, LoadingMarkComponent, MenuComponent, MenuItemComponent, ModalComponent, MultiTextFieldComponent, NavUserComponent, ORB_PERIODS, OauthButtonComponent, OptionItemComponent, PopoverComponent, QueryBuilderComponent, STATUS_TONES, STATUS_VOCAB, STATUS_VOCABS, STATUS_VOCABS_PENDING, ScrollAreaComponent, SearchBarComponent, SegmentGroupComponent, SegmentedControlComponent, SelectComponent, ShowMoreComponent, StatusChipComponent, StatusStateComponent, TagComponent, TextAreaComponent, TextButtonComponent, TextComponent, TextFieldComponent, TooltipComponent, WizardComponent, WizardController, WizardNavComponent, createWizard, pose, poseIso, poseSpeaking, poseThinking, renderCubeSvg, resolveIllustration, resolveStatus, statusOptions, statusOrder, statusToneVars, statusVocab, voiceEnv };
+export type { ActuacionStatus, AlertSize, AlertTone, AlertVariant, CountdownDirection, CountdownFormat, CountdownRingSize, CountdownRingTone, DescriptionListItem, DescriptionListLayout, DescriptionListSize, DescriptionListValueClick, GestionStatus, 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, IusDropdownItem, IusDropdownTone, IusDropdownVariant, IusEleniaBubblePosition, IusEleniaBubbleSize, IusEleniaOrbMood, IusEleniaOrbSurface, IusEmptyStateAction, IusEmptyStateSize, IusEmptyStateTone, IusEmptyStateVariant, IusFilterField, IusFilterFieldOption, IusFilterFieldType, IusFilterRule, IusFilterValue, IusFlexAlign, IusFlexDirection, IusFlexGap, IusFlexJustify, IusIconButtonShape, IusIconButtonSize, IusIconButtonVariant, IusInsigniaSize, IusInsigniaTone, IusInsigniaVariant, IusLoadingMarkSurface, IusLoadingVariant, IusMenuItemSize, IusMenuItemState, IusMenuItemVariant, IusMenuOption, IusModalCloseReason, IusModalIconTone, IusModalSize, IusMultiTextFieldSize, IusMultiTextFieldSlot, IusMultiTextFieldState, IusNavUserAccount, IusNavUserLayout, IusNavUserUser, IusOAuthButtonSize, IusOAuthButtonType, IusOAuthProvider, IusOptionItemSize, IusOptionItemState, IusPopoverPadding, IusPopoverPlacement, IusPopoverTrigger, IusQueryBuilderSize, IusScrollAxis, IusScrollSize, IusSearchBarSize, IusSearchBarState, IusSegmentedSize, IusSegmentedVariant, IusSelectCreateFactory, IusSelectSize, IusSelectState, IusSelectValue, IusShowMoreAlign, IusStatusChipSize, IusStatusChipTone, IusStatusKind, IusTagRole, IusTagShape, IusTagSize, IusTagState, IusTagTone, IusTagVariant, IusTextAlign, IusTextAreaSize, IusTextAreaState, IusTextButtonSize, IusTextButtonType, IusTextColor, IusTextFieldSize, IusTextFieldType, IusTextTag, IusTextVariant, IusTextWeight, IusTooltipTrigger, OrbMood, OrbPose, SegmentedOption, SelectOption, SelectOptionGroup, StatusMeta, StatusOption, StatusTone, StatusToneVars, StatusVocabMap, StatusVocabName, UseWizardOptions, WizardApi, WizardStep };