@litigiovirtual/ius-design-components 2.0.2 → 2.0.4

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

@@ -2221,7 +2221,7 @@ declare class TextComponent {
     /** Overrides por token (color/weight/align/italic-inline/tabular/truncate). */
     protected get styleObject(): Record<string, string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextComponent, "ius-text", never, { "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "weight": { "alias": "weight"; "required": false; }; "as": { "alias": "as"; "required": false; }; "align": { "alias": "align"; "required": false; }; "italic": { "alias": "italic"; "required": false; }; "truncate": { "alias": "truncate"; "required": false; }; "tabularNums": { "alias": "tabularNums"; "required": false; }; "for": { "alias": "for"; "required": false; }; }, {}, never, ["*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextComponent, "ius-text", never, { "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "weight": { "alias": "weight"; "required": false; }; "as": { "alias": "as"; "required": false; }; "align": { "alias": "align"; "required": false; }; "italic": { "alias": "italic"; "required": false; }; "truncate": { "alias": "truncate"; "required": false; }; "tabularNums": { "alias": "tabularNums"; "required": false; }; "for": { "alias": "for"; "required": false; }; }, {}, never, ["*"], true, never>;
     static ngAcceptInputType_italic: unknown;
     static ngAcceptInputType_truncate: unknown;
     static ngAcceptInputType_tabularNums: unknown;
@@ -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 };