yukit-web 0.0.1

package/types/yukit-web.d.ts

@@ -0,0 +1,2426 @@
+import { ClassValue } from 'clsx';
+import * as _angular_core from '@angular/core';
+import { ModelSignal, Type, Provider, InputSignal, InputSignalWithTransform, TemplateRef, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ButtonVariants } from 'yukit-web/helm/button';
+import * as i1 from 'yukit-web/helm/badge';
+import * as yukit_web from 'yukit-web';
+import { HlmAccordion, HlmAccordionItem } from 'yukit-web/helm/accordion';
+import { HlmLabel } from 'yukit-web/helm/label';
+import * as i1$1 from 'yukit-web/helm/skeleton';
+import * as i1$2 from 'yukit-web/helm/card';
+import * as i1$3 from 'yukit-web/helm/empty';
+import * as i1$4 from 'yukit-web/helm/context-menu';
+import * as i2 from 'yukit-web/helm/dropdown-menu';
+import * as i1$5 from 'yukit-web/helm/table';
+import * as _tanstack_angular_table from '@tanstack/angular-table';
+import { columnFilteringFeature, columnVisibilityFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature, RowData, ColumnDef, SortingState, ColumnFiltersState, ColumnVisibilityState, RowSelectionState, PaginationState } from '@tanstack/table-core';
+import * as i1$6 from 'yukit-web/helm/item';
+import { HlmItemSeparator } from 'yukit-web/helm/item';
+import * as i1$7 from '@spartan-ng/brain/tooltip';
+import { ToastOptions } from '@spartan-ng/brain/sonner';
+export { toast as yuwToast } from '@spartan-ng/brain/sonner';
+import * as i1$8 from 'yukit-web/helm/attachment';
+import { HlmAttachmentAction } from 'yukit-web/helm/attachment';
+import * as i1$9 from 'yukit-web/helm/sidebar';
+export { HlmSidebarConfig as YuwSidebarConfigDto, HlmSidebarService as YuwSidebarService, SidebarVariant as YuwSidebarServiceVariantDto, provideHlmSidebarConfig as provideYuwSidebarConfig } from 'yukit-web/helm/sidebar';
+
+/**
+ * Merges class lists the shadcn/Spartan way: `clsx` resolves conditionals/arrays, `twMerge`
+ * then drops earlier Tailwind classes that a later one overrides (e.g. `px-3 ... px-4` keeps
+ * only `px-4`) instead of shipping both to the DOM.
+ *
+ * Every yukit-web component's variant classes are combined through this, so a consumer's own
+ * `class` input always wins over the component's defaults without fighting specificity.
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Registers a component as a form control, so `formControlName`/`formControl`/`ngModel` bind to it.
+ *
+ * Spartan's own controls mostly don't need this: `hlmInput` and `hlmTextarea` are *directives on a
+ * native element*, so Angular's built-in `DefaultValueAccessor` already applies to the same host.
+ * The moment we wrap that native element inside a component template, the host a consumer writes
+ * `formControlName` on is no longer the `<input>` — Angular finds no accessor there and throws
+ * `NG01203`. This restores what the wrapping cost us.
+ *
+ * Kept as a `useExisting` + `forwardRef` provider because the class is referenced in its own
+ * decorator metadata, before the class binding is initialized.
+ */
+declare function provideValueAccessor(component: Type<unknown>): Provider;
+/**
+ * Shared `ControlValueAccessor` for the library's text-entry controls.
+ *
+ * Exists so the five text components don't each carry a near-identical copy of the same CVA
+ * plumbing — the single-responsibility and DRY concerns in `agents.md`. Subclasses supply nothing;
+ * they just extend it, add the provider, and bind `value`/`_onBlur()` in their template.
+ *
+ * ## Why `disabled` needs care
+ *
+ * `disabled` has two sources that don't know about each other: our own `disabled` input, and the
+ * forms API calling `setDisabledState()` (which is what `new FormControl({value, disabled: true})`
+ * and `control.disable()` go through). Letting either one own a single signal means the last
+ * writer wins and the other is silently ignored — the classic bug in hand-rolled accessors.
+ *
+ * They're kept as two separate signals and OR'd together in `disabledState`: disabled by *either*
+ * source means disabled. That's the only combination that never drops a caller's intent.
+ */
+declare abstract class YuwValueAccessorBase<T> implements ControlValueAccessor {
+    abstract readonly value: ModelSignal<T>;
+    protected abstract _emptyValue(): T;
+    protected readonly _formDisabled: _angular_core.WritableSignal<boolean>;
+    private _onChange;
+    private _onTouched;
+    protected _isDisabled(ownDisabled: boolean): boolean;
+    protected _commit(next: T): void;
+    protected _onBlur(): void;
+    writeValue(value: T | null | undefined): void;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwValueAccessorBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwValueAccessorBase<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+type YuwInputTypeDto = 'text' | 'email' | 'tel' | 'url' | 'number';
+type YuwInputModeDto = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+interface YuwTextFieldContract {
+    readonly value: ModelSignal<string>;
+    readonly inputId: InputSignal<string | undefined>;
+    readonly placeholder: InputSignal<string | undefined>;
+    readonly disabled: InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: InputSignalWithTransform<boolean, unknown>;
+    readonly required: InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: InputSignalWithTransform<boolean, unknown>;
+    readonly name: InputSignal<string | undefined>;
+    readonly autocomplete: InputSignal<string | undefined>;
+}
+
+type YuwColorDto = 'primary' | 'secondary' | 'destructive' | 'success' | 'warning' | 'info' | 'muted' | 'violet';
+
+/**
+ * A single entry in `<yuw-button>`'s `buttons` input, which turns it into a welded button group.
+ *
+ * variant`, `size` and `color` are optional and fall back to the component-level inputs of the
+ * same name, so a uniform row stays `{id, label}` entries plus one `variant`, and only the odd
+ * one out carries its own.
+ *
+ * `label` is data the parent supplies, not a component-owned default — the same i18n rule
+ * `YuwBreadcrumbItemDto` and `YuwSelectOptionDto` follow.
+ */
+interface YuwButtonGroupItemDto {
+    id: string;
+    label: string;
+    variant?: ButtonVariants['variant'];
+    size?: ButtonVariants['size'];
+    color?: YuwColorDto;
+    disabled?: boolean;
+    href?: string;
+    target?: string;
+    type?: 'button' | 'submit' | 'reset';
+    ariaLabel?: string;
+    yuwDropdownMenuTrigger?: TemplateRef<unknown> | undefined;
+    transparent?: boolean;
+}
+/** What `<yuw-button>` emits from `buttonClicked` in the group form. */
+interface YuwButtonGroupClickDto {
+    id: string;
+    event: MouseEvent;
+}
+
+/**
+ * Button component supporting single action button or grouped button options.
+ *
+ * Inputs:
+ * - `variant`: Button style variant (`'default'`, `'secondary'`, `'outline'`, `'destructive'`, `'ghost'`, `'link'`). Default is `'default'`.
+ * - `size`: Button size (`'default'`, `'sm'`, `'lg'`, `'icon'`, etc.). Default is `'default'`.
+ * - `color`: Brand color theme (any `YuwColorDto` value). Default is `'secondary'`.
+ * - `disabled`: Disables button interactions.
+ * - `type`: HTML button type (`'button'`, `'submit'`, `'reset'`). Default is `'button'`.
+ * - `href`: Renders button as an anchor tag navigating to specified URL.
+ * - `target`: Target attribute for link button (e.g. `'_blank'`).
+ * - `transparent`: Removes background and border styling.
+ * - `class`: Extra CSS classes merged onto the inner button/anchor (single and link mode); merged last, so they win over the component's own classes.
+ * - `yuwDropdownMenuTrigger`: Optional dropdown menu template reference to trigger.
+ * - `ariaLabel`: Accessible label for screen readers.
+ * - `buttons`: Array of button items (`YuwButtonGroupItemDto[]`) to render as a welded button group.
+ * - `orientation`: Group layout orientation (`'horizontal'` or `'vertical'`). Default is `'horizontal'`.
+ * - `groupAriaLabel`: Accessible name for button group container.
+ *
+ * Outputs:
+ * - `clicked`: Emits MouseEvent on single button click.
+ * - `buttonClicked`: Emits object containing clicked button `id` and `event` in group mode.
+ *
+ * Single Button Usage:
+ * ```html
+ * <yuw-button variant="outline" color="primary" (clicked)="onSave()">Save</yuw-button>
+ * <yuw-button href="/dashboard">Navigate</yuw-button>
+ * ```
+ *
+ * Button Group Usage:
+ * ```html
+ * <yuw-button [buttons]="actionList" (buttonClicked)="onAction($event)" />
+ * ```
+ */
+declare class YuwButtonComponent {
+    readonly variant: _angular_core.InputSignal<"secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    readonly color: _angular_core.InputSignal<YuwColorDto>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    readonly href: _angular_core.InputSignal<string | undefined>;
+    readonly target: _angular_core.InputSignal<string | undefined>;
+    readonly transparent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly yuwDropdownMenuTrigger: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly buttons: _angular_core.InputSignal<YuwButtonGroupItemDto[] | undefined>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly groupAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Consumer CSS classes for the inner button/anchor (single and link mode). Merged last with
+     * `cn`, so they win over the component's own variant/transparent classes.
+     */
+    readonly userClass: _angular_core.InputSignal<string>;
+    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly buttonClicked: _angular_core.OutputEmitterRef<YuwButtonGroupClickDto>;
+    protected readonly _isGroup: _angular_core.Signal<boolean>;
+    /** Classes for the single-mode button/anchor: our variant layer + the consumer's `class`, which goes last so it wins. */
+    protected readonly _btnClass: _angular_core.Signal<string>;
+    protected readonly _resolved: _angular_core.Signal<{
+        variant: "secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined;
+        size: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+        color: YuwColorDto;
+        disabled: boolean;
+        type: "button" | "submit" | "reset";
+        class: string;
+        id: string;
+        label: string;
+        href?: string;
+        target?: string;
+        ariaLabel?: string;
+        yuwDropdownMenuTrigger?: TemplateRef<unknown> | undefined;
+        transparent?: boolean;
+    }[]>;
+    protected onClick(event: MouseEvent): void;
+    protected onGroupClick(button: YuwButtonGroupItemDto, event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwButtonComponent, "yuw-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "transparent": { "alias": "transparent"; "required": false; "isSignal": true; }; "yuwDropdownMenuTrigger": { "alias": "yuwDropdownMenuTrigger"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "buttons": { "alias": "buttons"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "groupAriaLabel": { "alias": "groupAriaLabel"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; "buttonClicked": "buttonClicked"; }, never, ["[yuwButtonIcon]", "*", "[yuwButtonIcon]", "*"], true, never>;
+}
+
+/**
+ * Renders a small badge or tag component for status indicators, counts, and category labels.
+ *
+ * Supports the shared color vocabulary (`color`, any `YuwColorDto` value), variant styles
+ * (`variant`), dismissible action (`removeLabel` / `removed`), and a compact dot mode (`dot`)
+ * that renders no content at all.
+ *
+ * Usage:
+ * ```html
+ * <yuw-badge color="primary">New</yuw-badge>
+ * <yuw-badge removeLabel="Remove tag" (removed)="onRemove()">Category</yuw-badge>
+ * <yuw-badge dot color="success" />
+ * ```
+ */
+declare class YuwBadgeComponent {
+    readonly color: _angular_core.InputSignal<YuwColorDto>;
+    readonly removeLabel: _angular_core.InputSignal<string | undefined>;
+    readonly dot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    protected readonly dotClass: _angular_core.Signal<"" | "size-4 p-0">;
+    protected onRemoveClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwBadgeComponent, "yuw-badge", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["[yuwBadgeIcon]", "*"], true, [{ directive: typeof i1.HlmBadge; inputs: { "variant": "variant"; }; outputs: {}; }]>;
+}
+
+/** A single crumb in `<yuw-breadcrumb>`'s `items` input. */
+interface YuwBreadcrumbItemDto {
+    label: string;
+    href?: string;
+}
+
+/**
+ * Navigation breadcrumb bar displaying page hierarchy and links.
+ *
+ * Accepts an array of item objects (`items`), custom separator text (`separator`), and a required
+ * accessible label (`ariaLabel`). The last item is announced as the current page
+ * (`aria-current="page"`); intermediate items render as links when they have an `href` and as
+ * plain text otherwise.
+ *
+ * Usage:
+ * ```html
+ * <yuw-breadcrumb
+ *   [items]="[{ label: 'Inicio', href: '/' }, { label: 'Ajustes' }]"
+ *   ariaLabel="Ruta de navegación"
+ * />
+ * ```
+ */
+declare class YuwBreadcrumbComponent {
+    readonly items: _angular_core.InputSignal<YuwBreadcrumbItemDto[]>;
+    readonly separator: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwBreadcrumbComponent, "yuw-breadcrumb", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Sizes accepted by `<yuw-pagination>`'s `size` input. Mirrors the helm button sizes so the
+ * public API doesn't leak the helm's `ButtonVariants` type.
+ */
+type YuwPaginationSizeDto = 'default' | 'xs' | 'sm' | 'lg' | 'icon' | 'icon-xs' | 'icon-sm' | 'icon-lg';
+/**
+ * Pagination navigation bar for navigating multi-page content datasets.
+ *
+ * Controls two-way active page state `[(page)]`, accepts total pages (`totalPages`), accessible
+ * previous/next/ellipsis labels, size and color theme.
+ *
+ * Usage:
+ * ```html
+ * <yuw-pagination
+ *   [(page)]="currentPage"
+ *   [totalPages]="10"
+ *   previousLabel="Página anterior"
+ *   nextLabel="Página siguiente"
+ *   ellipsisSrText="Más páginas"
+ * />
+ * ```
+ */
+declare class YuwPaginationComponent {
+    readonly page: _angular_core.ModelSignal<number>;
+    readonly totalPages: _angular_core.InputSignal<number>;
+    readonly previousLabel: _angular_core.InputSignal<string>;
+    readonly nextLabel: _angular_core.InputSignal<string>;
+    readonly ellipsisSrText: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<YuwPaginationSizeDto>;
+    readonly color: _angular_core.InputSignal<YuwColorDto>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly range: _angular_core.Signal<yukit_web.YuwPaginationRangeItem[]>;
+    protected goTo(target: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwPaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwPaginationComponent, "yuw-pagination", never, { "page": { "alias": "page"; "required": true; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": true; "isSignal": true; }; "previousLabel": { "alias": "previousLabel"; "required": true; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": true; "isSignal": true; }; "ellipsisSrText": { "alias": "ellipsisSrText"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": true; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
+}
+
+type YuwPaginationRangeItem = number | 'ellipsis';
+/**
+ * Pure function on purpose: the page-range math has nothing to do with Angular, so it's testable
+ * in isolation and keeps `pagination.component.ts` limited to wiring inputs/outputs.
+ *
+ * Always shows page 1 and the last page, plus the current page and its immediate neighbors,
+ * collapsing any gap into a single `'ellipsis'` entry.
+ */
+declare function getPaginationRange(page: number, totalPages: number): YuwPaginationRangeItem[];
+
+/**
+ * A single entry in `<yuw-combobox>`'s `options` input.
+ *
+ * `label` is data the parent supplies, not a component-owned default — the same rule
+ * `YuwSelectOptionDto` and `YuwBreadcrumbItemDto` follow. It doubles as the text the search
+ * filters on and the text shown in the trigger/chip once selected, so it must be the
+ * already-translated string.
+ *
+ * `data` carries whatever the consumer needs when rendering a custom item template
+ * (`*yuwComboboxItem`) — an avatar URL, a count, a nested entity. The component itself never
+ * reads it.
+ */
+interface YuwComboboxOptionDto<TData = unknown> {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    data?: TData;
+}
+
+/** The `let-` context of a `*yuwComboboxItem` template. `$implicit` is the option itself, so
+ * `let-option` works; `selected` is passed alongside because an item that renders its own
+ * markup loses the default check glyph and often needs to show that state some other way. */
+interface YuwComboboxItemContext<TData = unknown> {
+    $implicit: YuwComboboxOptionDto<TData>;
+    option: YuwComboboxOptionDto<TData>;
+    selected: boolean;
+}
+/**
+ * Structural directive for custom option item templates in `yuw-combobox`.
+ *
+ * Exposes the option object (`let-option`) and selection state (`let-selected="selected"`).
+ *
+ * Usage:
+ * ```html
+ * <yuw-combobox [options]="users" [(value)]="userId">
+ *   <ng-template yuwComboboxItem let-option let-selected="selected">
+ *     <img [src]="option.data.avatar" /> {{ option.label }}
+ *   </ng-template>
+ * </yuw-combobox>
+ * ```
+ */
+declare class YuwComboboxItemDirective<TData = unknown> {
+    readonly templateRef: TemplateRef<YuwComboboxItemContext<TData>>;
+    readonly typeOf: _angular_core.InputSignal<YuwComboboxOptionDto<TData>[] | undefined>;
+    static ngTemplateContextGuard<TData>(_directive: YuwComboboxItemDirective<TData>, _context: unknown): _context is YuwComboboxItemContext<TData>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwComboboxItemDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwComboboxItemDirective<any>, "[yuwComboboxItem]", never, { "typeOf": { "alias": "yuwComboboxItemTypeOf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type YuwComboboxValue = string | string[] | undefined;
+/**
+ * Searchable select combobox component supporting single or multiple selections, search filtering, and custom option rendering.
+ *
+ * Inputs / Models:
+ * - `options`: Required array of option items (`YuwComboboxOptionDto<TData>[]`).
+ * - `value`: Two-way selected value(s) (`string` for single mode, `string[]` for multiple mode).
+ *   Emits `valueChange` on every selection change.
+ * - `multiple`: Enables multi-selection mode with removable tags/chips.
+ * - `disabled`: Disables combobox interaction.
+ * - `placeholder`: Placeholder text when no option is selected.
+ * - `searchPlaceholder`: Placeholder text inside the search field popover.
+ * - `emptyText`: Message text displayed when search yields no matching options.
+ * - `search`: Two-way search filter query string.
+ * - `triggerAriaLabel`: Required accessible name for the icon-only popover trigger (the chevron
+ *   button). User-facing text — the consuming app is responsible for providing it translated.
+ *   Only rendered by the single-select input shape, but required in every mode so switching
+ *   modes never silently drops the label.
+ * - `clearAriaLabel`: When set, the clear button is shown on the single-selection control and
+ *   this is its accessible name; when absent, there is no clear button. One input, one source of
+ *   truth. User-facing text — the consuming app is responsible for providing it translated.
+ * - `inputId`: HTML `id` for the focusable control (the search input, or the trigger button when
+ *   `readonlyTrigger` is set), enabling external `<label for="...">` association.
+ * - `readonlyTrigger`: Renders control as a button showing selected label, placing search input inside popover.
+ * - `invalid`: Forces invalid styling.
+ *
+ * `multiple` takes precedence over `readonlyTrigger`: when both are set the multi-select
+ * chips shape renders and `readonlyTrigger` is ignored.
+ *
+ * Usage:
+ * ```html
+ * <yuw-combobox [options]="userOptions" [(value)]="selectedUser" placeholder="Select user..."
+ *   triggerAriaLabel="Toggle options" clearAriaLabel="Clear selection" />
+ * <yuw-combobox [options]="categoryOptions" [(value)]="selectedCategories" multiple
+ *   triggerAriaLabel="Toggle options" />
+ * ```
+ */
+declare class YuwComboboxComponent<TData = unknown> extends YuwValueAccessorBase<YuwComboboxValue> {
+    readonly options: _angular_core.InputSignal<YuwComboboxOptionDto<TData>[]>;
+    readonly value: _angular_core.ModelSignal<YuwComboboxValue>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string | undefined>;
+    readonly emptyText: _angular_core.InputSignal<string | undefined>;
+    readonly search: _angular_core.ModelSignal<string>;
+    readonly triggerAriaLabel: _angular_core.InputSignal<string>;
+    readonly clearAriaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly readonlyTrigger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly itemTemplate: _angular_core.Signal<YuwComboboxItemDirective<TData> | undefined>;
+    private readonly _panel;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    protected readonly _clearVisible: _angular_core.Signal<boolean>;
+    private readonly _generatedId;
+    protected readonly _controlId: _angular_core.Signal<string>;
+    protected readonly _singleValue: _angular_core.Signal<string | undefined>;
+    protected readonly _multipleValue: _angular_core.Signal<string[]>;
+    private readonly _labelByValue;
+    protected readonly _selectedChips: _angular_core.Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    protected readonly _selectedValues: _angular_core.Signal<Set<string>>;
+    protected readonly _itemToString: (value: string) => string;
+    protected _emptyValue(): YuwComboboxValue;
+    protected onValueChange(next: YuwComboboxValue | null): void;
+    protected _onFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwComboboxComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwComboboxComponent<any>, "yuw-combobox", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "triggerAriaLabel": { "alias": "triggerAriaLabel"; "required": true; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "readonlyTrigger": { "alias": "readonlyTrigger"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "search": "searchChange"; }, ["itemTemplate"], never, true, never>;
+}
+
+/**
+ * Container directive for collapsible accordion items.
+ *
+ * Renders a full-width flexible vertical container for `yuw-accordion-item` elements.
+ * Supports single (`type="single"`) or multiple (`type="multiple"`) expandable items,
+ * as well as vertical or horizontal orientation (`orientation`).
+ *
+ * Direct child items (`yuw-accordion-item`) can be declared statically or rendered dynamically
+ * using `@for`.
+ *
+ * Extends `HlmAccordion` (instead of re-applying `BrnAccordion` and copying the helm's classes
+ * by hand) so the helm's `data-slot`, classes and its `BrnAccordion` host directive — including
+ * the forwarded `type`/`orientation` inputs — are all inherited. Forwarding those inputs through
+ * a `hostDirectives` entry on `HlmAccordion` is not possible: Angular only allows exposing
+ * inputs a host directive declares itself, and the helm exposes them transitively from
+ * `BrnAccordion`.
+ */
+declare class YuwAccordion extends HlmAccordion {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAccordion, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAccordion, "yuw-accordion", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive representing an individual section/item within a `yuw-accordion`.
+ *
+ * Encloses a `yuw-accordion-trigger` button and a `yuw-accordion-content` panel.
+ * Accepts `isOpened` (boolean) to control open state and `disabled` (boolean) to disable
+ * interaction. Emits `openedChange` when the item is expanded or collapsed.
+ *
+ * Extends `HlmAccordionItem` (instead of re-applying `BrnAccordionItem` and copying the helm's
+ * classes by hand) so the helm's `data-slot`, classes and its `BrnAccordionItem` host directive —
+ * including the forwarded `isOpened`/`disabled` inputs and `openedChange` output — are all
+ * inherited. Forwarding those through a `hostDirectives` entry on `HlmAccordionItem` is not
+ * possible: Angular only allows exposing inputs/outputs a host directive declares itself, and
+ * the helm exposes them transitively from `BrnAccordionItem`.
+ */
+declare class YuwAccordionItem extends HlmAccordionItem {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAccordionItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAccordionItem, "yuw-accordion-item", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Interactive header button for expanding or collapsing a `yuw-accordion-item`.
+ *
+ * Project content inside to serve as the trigger label (text, icons, badges, or custom markup).
+ *
+ * Inputs:
+ * - `triggerClass`: Extra classes for the inner trigger `<button>`; the helm merges them last
+ *   (via tailwind-merge), so they win over its defaults.
+ */
+declare class YuwAccordionTriggerComponent {
+    readonly triggerClass: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAccordionTriggerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwAccordionTriggerComponent, "yuw-accordion-trigger", never, { "triggerClass": { "alias": "triggerClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Collapsible panel container for a `yuw-accordion-item`.
+ *
+ * Projects body content revealed when the item is expanded (supports text, custom markup, or nested components).
+ */
+declare class YuwAccordionContentComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAccordionContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwAccordionContentComponent, "yuw-accordion-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+/** Bundle for consumers who want every `yuw-accordion-*` piece in one `imports: [...]` entry —
+ * same shape as Spartan's own `HlmAccordionImports`. Each piece is still exported and importable
+ * on its own for consumers who only need a subset. */
+declare const YuwAccordionImports: readonly [typeof YuwAccordion, typeof YuwAccordionItem, typeof YuwAccordionTriggerComponent, typeof YuwAccordionContentComponent];
+
+/**
+ * Single-line text input control supporting two-way value binding, form controls (`formControlName`, `ngModel`),
+ * validation styling, and left/right addon slots.
+ *
+ * Inputs / Models:
+ * - `value`: Two-way text string.
+ * - `inputId`: `id` applied to the native input, for external `<label for>` association.
+ * - `type`: HTML input type (`'text'`, `'email'`, `'number'`, etc.). Default is `'text'`.
+ * - `inputmode`: Virtual keyboard hint (e.g. `'numeric'`).
+ * - `disabled`: Disables input interaction.
+ * - `readonly`: Makes the field read-only.
+ * - `required`: Marks the field as required.
+ * - `invalid`: Forces invalid styling.
+ * - `name`: HTML `name` attribute.
+ * - `autocomplete`: Native `autocomplete` attribute.
+ * - `maxlength`: Hard cap on character count, enforced natively by the browser.
+ * - `placeholder`: Hint text shown inside the empty field.
+ * - `class`: Extra classes merged onto the visual root (the input, or the input group when addons are present).
+ *
+ * Outputs:
+ * - `committed`: Emits the current value on the native `change` event (blur/enter).
+ *
+ * Usage:
+ * ```html
+ * <yuw-input [(value)]="username" placeholder="Enter username..." />
+ *
+ * <yuw-input formControlName="email" type="email">
+ *   <yuw-left-addon><ng-icon name="lucideMail" /></yuw-left-addon>
+ * </yuw-input>
+ * ```
+ */
+declare class YuwInputComponent extends YuwValueAccessorBase<string> implements YuwTextFieldContract {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly type: _angular_core.InputSignal<YuwInputTypeDto>;
+    readonly inputmode: _angular_core.InputSignal<YuwInputModeDto | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly autocomplete: _angular_core.InputSignal<string | undefined>;
+    readonly maxlength: _angular_core.InputSignal<number | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    readonly committed: _angular_core.OutputEmitterRef<string>;
+    protected readonly _autoId: string;
+    protected readonly _inputId: _angular_core.Signal<string>;
+    protected readonly _classes: _angular_core.Signal<string>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    private readonly _leftAddons;
+    private readonly _rightAddons;
+    protected readonly _hasLeftAddon: _angular_core.Signal<boolean>;
+    protected readonly _hasRightAddon: _angular_core.Signal<boolean>;
+    protected readonly _hasAddons: _angular_core.Signal<boolean>;
+    protected onInput(event: Event): void;
+    protected _emptyValue(): string;
+    protected onChange(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwInputComponent, "yuw-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "inputmode": { "alias": "inputmode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "committed": "committed"; }, ["_leftAddons", "_rightAddons"], ["yuw-left-addon", "yuw-right-addon"], true, never>;
+}
+
+/**
+ * Slot directive for adding content (icons, text prefixes) on the left side of a `yuw-input` or `yuw-textarea`.
+ */
+declare class YuwLeftAddonDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwLeftAddonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwLeftAddonDirective, "yuw-left-addon", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Slot directive for adding content (icons, text suffixes, action buttons) on the right side of a `yuw-input` or `yuw-textarea`.
+ */
+declare class YuwRightAddonDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwRightAddonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwRightAddonDirective, "yuw-right-addon", never, {}, {}, never, never, true, never>;
+}
+declare const YuwInputAddonImports: readonly [typeof YuwLeftAddonDirective, typeof YuwRightAddonDirective];
+
+/**
+ * Multi-line text input control supporting auto-growing content, character limits, row count, and form integration (`ngModel`, `formControlName`).
+ *
+ * Inputs / Models:
+ * - `value`: Two-way text string.
+ * - `inputId`: `id` applied to the native textarea, for external `<label for>` association.
+ * - `disabled`: Disables input interaction.
+ * - `readonly`: Makes the field read-only.
+ * - `required`: Marks the field as required.
+ * - `invalid`: Forces invalid styling.
+ * - `name`: HTML `name` attribute.
+ * - `autocomplete`: Native `autocomplete` attribute.
+ * - `rows`: Fallback visible height in lines where `field-sizing` is unsupported; ignored otherwise.
+ * - `maxlength`: Hard cap on character count, enforced natively by the browser.
+ * - `placeholder`: Hint text shown inside the empty field.
+ * - `class`: Extra classes merged onto the visual root (the textarea, or the input group when addons are present).
+ *
+ * Outputs:
+ * - `committed`: Emits the current value on the native `change` event (blur/enter).
+ *
+ * Usage:
+ * ```html
+ * <yuw-textarea [(value)]="bio" placeholder="Write your biography..." [rows]="4" />
+ * <yuw-textarea formControlName="comments" [maxlength]="500" />
+ * ```
+ */
+declare class YuwTextareaComponent extends YuwValueAccessorBase<string> implements YuwTextFieldContract {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly autocomplete: _angular_core.InputSignal<string | undefined>;
+    readonly rows: _angular_core.InputSignal<number | undefined>;
+    readonly maxlength: _angular_core.InputSignal<number | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    readonly committed: _angular_core.OutputEmitterRef<string>;
+    protected readonly _autoId: string;
+    protected readonly _inputId: _angular_core.Signal<string>;
+    protected readonly _classes: _angular_core.Signal<string>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    private readonly _leftAddons;
+    private readonly _rightAddons;
+    protected readonly _hasLeftAddon: _angular_core.Signal<boolean>;
+    protected readonly _hasRightAddon: _angular_core.Signal<boolean>;
+    protected readonly _hasAddons: _angular_core.Signal<boolean>;
+    protected onInput(event: Event): void;
+    protected _emptyValue(): string;
+    protected onChange(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwTextareaComponent, "yuw-textarea", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "committed": "committed"; }, ["_leftAddons", "_rightAddons"], ["yuw-left-addon", "yuw-right-addon"], true, never>;
+}
+
+/**
+ * Search input control featuring a leading search icon, optional clear button, and form integration (`ngModel`, `formControlName`).
+ *
+ * Inputs / Models:
+ * - `value`: Two-way search query string.
+ * - `inputId`: `id` applied to the native input, for external `<label for>` association.
+ * - `disabled`: Disables input interaction.
+ * - `readonly`: Makes the field read-only.
+ * - `required`: Marks the field as required.
+ * - `invalid`: Forces invalid styling.
+ * - `name`: HTML `name` attribute.
+ * - `autocomplete`: Native `autocomplete` attribute.
+ * - `placeholder`: Hint text shown inside the empty field.
+ * - `clearAriaLabel`: Accessible name for the clear button. Supplying it enables the clear button; omit to hide it.
+ * - `class`: Extra classes merged onto the input group.
+ *
+ * Outputs:
+ * - `searched`: Emits the current query string on every keystroke.
+ * - `committed`: Emits the current query string when the user presses Enter — for searches that
+ *   hit a server on explicit submit rather than on every keystroke.
+ *
+ * Usage:
+ * ```html
+ * <yuw-search-input [(value)]="query" placeholder="Search items..." clearAriaLabel="Clear search" (searched)="onSearch($event)" />
+ * ```
+ */
+declare class YuwSearchInputComponent extends YuwValueAccessorBase<string> implements YuwTextFieldContract {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly autocomplete: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly clearAriaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    readonly searched: _angular_core.OutputEmitterRef<string>;
+    readonly committed: _angular_core.OutputEmitterRef<string>;
+    protected readonly _autoId: string;
+    protected readonly _inputId: _angular_core.Signal<string>;
+    protected readonly _classes: _angular_core.Signal<string>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    protected readonly _showClear: _angular_core.Signal<boolean>;
+    private readonly _input;
+    protected _emptyValue(): string;
+    protected onInput(event: Event): void;
+    protected onEnter(): void;
+    protected onClear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSearchInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwSearchInputComponent, "yuw-search-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "searched": "searched"; "committed": "committed"; }, never, never, true, never>;
+}
+
+/**
+ * Password input field with optional visibility toggle button and form integration (`ngModel`, `formControlName`).
+ *
+ * Inputs / Models:
+ * - `value`: Two-way password string.
+ * - `inputId`: `id` applied to the native input, for external `<label for>` association.
+ * - `disabled`: Disables input interaction.
+ * - `readonly`: Makes the field read-only.
+ * - `required`: Marks the field as required.
+ * - `invalid`: Forces invalid styling.
+ * - `name`: HTML `name` attribute.
+ * - `autocomplete`: Native `autocomplete` attribute (e.g. `'current-password'`, `'new-password'`).
+ * - `placeholder`: Hint text shown inside the empty field.
+ * - `revealAriaLabel`: Accessible name for the reveal toggle button. Supplying it enables the toggle; omit to hide it.
+ * - `masked`: Two-way boolean controlling whether the value is masked. Default is `true` (masked). A parent can reset it (e.g. re-mask after a failed submit).
+ * - `class`: Extra classes merged onto the input group.
+ *
+ * Outputs:
+ * - `committed`: Emits the current value on the native `change` event (blur/enter).
+ *
+ * Usage:
+ * ```html
+ * <yuw-password-input [(value)]="password" revealAriaLabel="Toggle password visibility" />
+ * <yuw-password-input formControlName="password" autocomplete="current-password" />
+ * ```
+ */
+declare class YuwPasswordInputComponent extends YuwValueAccessorBase<string> implements YuwTextFieldContract {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly autocomplete: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly revealAriaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    readonly committed: _angular_core.OutputEmitterRef<string>;
+    readonly masked: _angular_core.ModelSignal<boolean>;
+    protected readonly _autoId: string;
+    protected readonly _inputId: _angular_core.Signal<string>;
+    protected readonly _classes: _angular_core.Signal<string>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    protected readonly _reveal: _angular_core.Signal<yukit_web.YuwPasswordRevealStateDto>;
+    protected _emptyValue(): string;
+    protected onInput(event: Event): void;
+    protected onChange(): void;
+    protected onToggleReveal(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwPasswordInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwPasswordInputComponent, "yuw-password-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "revealAriaLabel": { "alias": "revealAriaLabel"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "masked": { "alias": "masked"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "committed": "committed"; "masked": "maskedChange"; }, never, never, true, never>;
+}
+
+/**
+ * The reveal toggle's two states, as data rather than control flow — `agents.md` bans `switch`
+ * over a mode, and a `[type]="masked() ? 'password' : 'text'"` chain in the template would be the
+ * same branch smeared across three separate bindings that can drift out of sync.
+ *
+ * Keyed by "is the value currently masked", so the component reads one boolean signal and gets
+ * the matching input type and icon together, always consistent.
+ */
+interface YuwPasswordRevealStateDto {
+    inputType: 'password' | 'text';
+    icon: 'lucideEye' | 'lucideEyeOff';
+    struck: boolean;
+}
+/** Lookup replacing the branch, keyed by `` `${boolean}` `` so a boolean signal indexes it
+ * directly (`STATES[`${masked()}`]`) with no ternary. Adding a third state (a "peek while held"
+ * mode, say) means adding an entry here — open for extension, closed for modification. */
+declare const YUW_PASSWORD_REVEAL_STATES: Record<`${boolean}`, YuwPasswordRevealStateDto>;
+
+type YuwInputOtpModeDto = 'numeric' | 'text';
+/**
+ * One-time password / verification code input component rendering grouped digit or text slots.
+ *
+ * Inputs / Models:
+ * - `value`: Two-way OTP code string.
+ * - `inputId`: `id` applied to the hidden native input, for external `<label for>` association.
+ * - `groupSizes`: Slot counts per visual group (`number[]`). A separator renders between groups, e.g. `[3, 3]` gives `000-000`. Default is `[6]`.
+ * - `mode`: Virtual-keyboard hint (`'numeric'`, `'text'`). Default is `'numeric'`.
+ * - `disabled`: Disables input interaction.
+ * - `invalid`: Forces invalid styling.
+ * - `autofocus`: Focuses the field on init. Appropriate on dedicated verification screens.
+ * - `transformPaste`: Normalizes pasted text before it fills the slots.
+ * - `class`: Extra classes merged onto the OTP container.
+ *
+ * Outputs:
+ * - `completed`: Emits the full code string once the final slot is filled (by typing or paste).
+ *
+ * Usage:
+ * ```html
+ * <yuw-input-otp [(value)]="code" [groupSizes]="[3, 3]" (completed)="verifyCode($event)" />
+ * <yuw-input-otp formControlName="otpCode" [groupSizes]="[6]" mode="numeric" />
+ * ```
+ */
+declare class YuwInputOtpComponent extends YuwValueAccessorBase<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly groupSizes: _angular_core.InputSignal<readonly number[]>;
+    readonly mode: _angular_core.InputSignal<YuwInputOtpModeDto>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly autofocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly transformPaste: _angular_core.InputSignal<(pastedText: string, length: number) => string>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    readonly completed: _angular_core.OutputEmitterRef<string>;
+    protected readonly _autoId: string;
+    protected readonly _inputId: _angular_core.Signal<string>;
+    protected readonly _classes: _angular_core.Signal<string>;
+    protected readonly _groups: _angular_core.Signal<yukit_web.YuwInputOtpGroupDto[]>;
+    protected readonly _length: _angular_core.Signal<number>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    protected _emptyValue(): string;
+    protected onValueChange(next: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwInputOtpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwInputOtpComponent, "yuw-input-otp", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "groupSizes": { "alias": "groupSizes"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "transformPaste": { "alias": "transformPaste"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "completed": "completed"; }, never, never, true, never>;
+}
+
+/**
+ * One rendered group of OTP slots, with the absolute slot indices it contains.
+ *
+ * `HlmInputOtpSlot` needs an explicit `[index]` per slot, and those indices are absolute across
+ * the whole input — the second group of a `3-3` layout holds slots 3,4,5, not 0,1,2. Precomputing
+ * them here keeps the template to two plain `@for`s with no arithmetic and no method calls.
+ */
+interface YuwInputOtpGroupDto {
+    indices: number[];
+    precededBySeparator: boolean;
+}
+/**
+ * Expands a list of group sizes (`[3, 3]`) into the groups the template renders, assigning
+ * absolute indices as it goes.
+ *
+ * Lives in its own file rather than inline in the component because `agents.md` wants the
+ * component file to read as inputs, outputs, a couple of `computed()`s, done — and because this
+ * is the one piece of real logic here, so it's the piece worth being able to test on its own.
+ *
+ * Sizes that are zero or negative are dropped: they'd contribute no slots but would still emit a
+ * stray separator, so a typo like `[3, 0, 3]` would render a dangling dash between two groups.
+ */
+declare function buildInputOtpGroups(groupSizes: readonly number[]): YuwInputOtpGroupDto[];
+/** Total slot count across every group — what `BrnInputOtp`'s own `length` input expects. Derived
+ * from the same source as the groups so the two can never disagree, which is the bug you get from
+ * accepting `length` and `groupSizes` as two independent inputs. */
+declare function totalInputOtpLength(groupSizes: readonly number[]): number;
+
+/**
+ * Form label directive applied directly to a native `<label>` element.
+ *
+ * Provides label styling and pairs with form controls using standard `for` attribute.
+ *
+ * Extends `HlmLabel` (instead of composing it via `hostDirectives`) because `id`/`for` are
+ * inputs `HlmLabel` itself re-exposes from `BrnLabel` through its own `hostDirectives`, and
+ * Angular's host-directive forwarding is not transitive (NG2017) — they can't be re-listed at
+ * this level. Class inheritance carries the whole surface over unchanged: a static `for`/`id`
+ * on the `<label>` reaches `BrnLabel` as an initial input, whose `[attr.for]` host binding then
+ * re-writes the same value.
+ *
+ * Usage:
+ * ```html
+ * <label yuwLabel for="username">Username</label>
+ * <yuw-input inputId="username" [(value)]="username" />
+ * ```
+ */
+declare class YuwLabel extends HlmLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwLabel, "label[yuwLabel]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Checkbox control supporting two-way boolean binding, form integration (`ngModel`, `formControlName`),
+ * indeterminate state, and secondary styling variant.
+ *
+ * Projected content becomes the checkbox's clickable label: the control is wrapped in a `<label>`,
+ * so clicking the text toggles it and the text is announced as the accessible name. Without
+ * projected content, pair it with an external `<label [for]>` via `inputId` or set `ariaLabel`.
+ *
+ * Inputs / Models:
+ * - `value` / `checked`: Two-way boolean state of the checkbox. Default is `false`.
+ * - `indeterminate`: Two-way boolean state for mixed/indeterminate checkbox appearance. Default is `false`.
+ * - `disabled`: Disables checkbox interaction.
+ * - `required`: Marks checkbox as required.
+ * - `invalid`: Forces invalid styling.
+ * - `name`: Form input name attribute.
+ * - `inputId`: ID set on the native input element for `<label [for]>` matching.
+ * - `ariaLabel`: Accessible name for screen readers when there's no visible label.
+ * - `ariaLabelledby`: ID of an external element that labels the checkbox.
+ * - `ariaDescribedby`: ID of an external element that describes the checkbox (hints, errors).
+ * - `secondary`: Enables secondary color variant styling.
+ *
+ * Usage:
+ * ```html
+ * <yuw-checkbox [(checked)]="acceptedTerms">Accept terms</yuw-checkbox>
+ * <yuw-checkbox [(indeterminate)]="isMixed" [(checked)]="allSelected" />
+ * <yuw-checkbox formControlName="rememberMe" />
+ * ```
+ */
+declare class YuwCheckboxComponent extends YuwValueAccessorBase<boolean> {
+    readonly value: _angular_core.ModelSignal<boolean>;
+    readonly indeterminate: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
+    readonly secondary: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    protected readonly _class: _angular_core.Signal<string>;
+    protected _emptyValue(): boolean;
+    protected onCheckedChange(checked: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwCheckboxComponent, "yuw-checkbox", never, { "value": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "ariaDescribedby"; "required": false; "isSignal": true; }; "secondary": { "alias": "secondary"; "required": false; "isSignal": true; }; }, { "value": "checkedChange"; "indeterminate": "indeterminateChange"; }, never, ["*"], true, never>;
+}
+
+type YuwSwitchSizeDto = 'default' | 'sm';
+/**
+ * Toggle switch control for binary settings and immediate state changes.
+ *
+ * Projected content becomes the switch's clickable label: the control is wrapped in a `<label>`,
+ * so clicking the text toggles it and the text is announced as the accessible name. Without
+ * projected content, pair it with an external `<label [for]>` via `inputId` or set `ariaLabel`.
+ *
+ * Inputs / Models:
+ * - `checked` (alias for `value`): Two-way boolean on/off state. Bind as `[(checked)]`.
+ * - `size`: Track size variant (`'default'`, `'sm'`). Default is `'default'`.
+ * - `disabled`: Disables switch interaction.
+ * - `inputId`: HTML `id` for the underlying control, enabling external `<label for="...">` association.
+ * - `ariaLabel`: Accessible name for switches with no visible adjacent label.
+ *
+ * Usage:
+ * ```html
+ * <yuw-switch [(checked)]="notificationsEnabled">Enable Notifications</yuw-switch>
+ * <yuw-switch formControlName="darkMode" size="sm" />
+ * ```
+ */
+declare class YuwSwitchComponent extends YuwValueAccessorBase<boolean> {
+    readonly value: _angular_core.ModelSignal<boolean>;
+    readonly size: _angular_core.InputSignal<YuwSwitchSizeDto>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    protected _emptyValue(): boolean;
+    protected onCheckedChange(checked: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwSwitchComponent, "yuw-switch", never, { "value": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "ariaDescribedby"; "required": false; "isSignal": true; }; }, { "value": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A single option in `<yuw-radio-group>`'s `options` input.
+ *
+ * `label` is data the parent supplies, not a component-owned default — the same rule
+ * `YuwSelectOptionDto` and `YuwBreadcrumbItemDto` follow, and what keeps translatable copy in the
+ * consuming app.
+ *
+ * `disabled` is per-option because a group can legitimately offer a choice that's currently
+ * unavailable while the rest stay selectable; disabling the whole group is the group's own input.
+ */
+interface YuwRadioOptionDto {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+
+/**
+ * Radio button group component for selecting a single option from a list.
+ *
+ * Inputs / Models:
+ * - `value`: Two-way selected option value (`string | undefined`). `undefined` means nothing is selected.
+ * - `options`: Required array of radio options (`YuwRadioOptionDto[]`).
+ * - `disabled`: Disables all radio options.
+ * - `required`: Marks the group as required.
+ * - `name`: Shared HTML `name` attribute for all radios, making them mutually exclusive in native
+ *   form submission. When omitted, a unique per-instance name is generated.
+ * - `ariaLabel`: Accessible name for the `role="radiogroup"` element. User-facing text — the
+ *   consuming app is responsible for providing it translated.
+ * - `ariaLabelledby`: ID of an external element (e.g. a visible heading) that labels the group.
+ * - `class`: Extra classes merged onto the group container (layout tweaks like
+ *   `grid-cols-2` or `flex-row`). The `gap-3` base stays unless overridden.
+ *
+ * Usage:
+ * ```html
+ * <yuw-radio-group [options]="planOptions" [(value)]="selectedPlan" ariaLabel="Plan" />
+ * <yuw-radio-group [options]="genderOptions" formControlName="gender" ariaLabelledby="gender-heading" />
+ * ```
+ */
+declare class YuwRadioGroupComponent extends YuwValueAccessorBase<string | undefined> {
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    readonly options: _angular_core.InputSignal<readonly YuwRadioOptionDto[]>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    private readonly _generatedName;
+    protected readonly _name: _angular_core.Signal<string>;
+    protected readonly _groupClass: _angular_core.Signal<string>;
+    protected _emptyValue(): string | undefined;
+    protected onValueChange(next: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwRadioGroupComponent, "yuw-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Loading skeleton placeholder directive with pulse animation effect.
+ *
+ * Sized using standard CSS height and width classes on the host element.
+ *
+ * Usage:
+ * ```html
+ * <div yuwSkeleton class="h-4 w-32 rounded"></div>
+ * <div yuwSkeleton class="size-10 rounded-full"></div>
+ * ```
+ */
+declare class YuwSkeletonDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSkeletonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSkeletonDirective, "[yuwSkeleton]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.HlmSkeleton; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Container directive for card components.
+ * Accepts optional `size` input (e.g. `'default'` or `'sm'`).
+ *
+ * Usage:
+ * ```html
+ * <div yuwCard>
+ *   <div yuwCardHeader>
+ *     <h3 yuwCardTitle>Title</h3>
+ *     <p yuwCardDescription>Description text</p>
+ *   </div>
+ *   <div yuwCardContent>Main content</div>
+ *   <div yuwCardFooter>Footer content</div>
+ * </div>
+ * ```
+ */
+declare class YuwCardDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCardDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCardDirective, "[yuwCard]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmCard; inputs: { "size": "size"; }; outputs: {}; }]>;
+}
+/** Header container directive for a card. */
+declare class YuwCardHeaderDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCardHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCardHeaderDirective, "[yuwCardHeader]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmCardHeader; inputs: {}; outputs: {}; }]>;
+}
+/** Heading directive for card title text. */
+declare class YuwCardTitleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCardTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCardTitleDirective, "[yuwCardTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmCardTitle; inputs: {}; outputs: {}; }]>;
+}
+/** Subtitle or description directive for card text. */
+declare class YuwCardDescriptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCardDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCardDescriptionDirective, "[yuwCardDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmCardDescription; inputs: {}; outputs: {}; }]>;
+}
+/** Header action directive for placing top-right controls (e.g. menu button or status badge). */
+declare class YuwCardActionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCardActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCardActionDirective, "[yuwCardAction]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmCardAction; inputs: {}; outputs: {}; }]>;
+}
+/** Main body container directive for card content. */
+declare class YuwCardContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCardContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCardContentDirective, "[yuwCardContent]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmCardContent; inputs: {}; outputs: {}; }]>;
+}
+/** Footer container directive for card action buttons or summary info. */
+declare class YuwCardFooterDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCardFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCardFooterDirective, "[yuwCardFooter]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmCardFooter; inputs: {}; outputs: {}; }]>;
+}
+/** Every card part, for a consumer's `imports`. */
+declare const YuwCardImports: readonly [typeof YuwCardDirective, typeof YuwCardHeaderDirective, typeof YuwCardTitleDirective, typeof YuwCardDescriptionDirective, typeof YuwCardActionDirective, typeof YuwCardContentDirective, typeof YuwCardFooterDirective];
+
+/**
+ * Container directive for empty-state layout panels (e.g., "No search results", "Inbox empty").
+ *
+ * Usage:
+ * ```html
+ * <div yuwEmpty>
+ *   <div yuwEmptyHeader>
+ *     <div yuwEmptyMedia>
+ *       <ng-icon name="lucideFolderOpen" />
+ *     </div>
+ *     <h3 yuwEmptyTitle>No files found</h3>
+ *     <p yuwEmptyDescription>Try uploading a file or changing your query.</p>
+ *   </div>
+ *   <div yuwEmptyContent>
+ *     <yuw-button>Upload File</yuw-button>
+ *   </div>
+ * </div>
+ * ```
+ */
+declare class YuwEmptyDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwEmptyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwEmptyDirective, "[yuwEmpty]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.HlmEmpty; inputs: {}; outputs: {}; }]>;
+}
+/** Header container directive for empty-state title and media. */
+declare class YuwEmptyHeaderDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwEmptyHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwEmptyHeaderDirective, "[yuwEmptyHeader]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.HlmEmptyHeader; inputs: {}; outputs: {}; }]>;
+}
+/** Slot directive for empty-state icons or illustrations. Supports `variant` input. */
+declare class YuwEmptyMediaDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwEmptyMediaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwEmptyMediaDirective, "[yuwEmptyMedia]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.HlmEmptyMedia; inputs: { "variant": "variant"; }; outputs: {}; }]>;
+}
+/** Title heading directive for empty state message. */
+declare class YuwEmptyTitleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwEmptyTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwEmptyTitleDirective, "[yuwEmptyTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.HlmEmptyTitle; inputs: {}; outputs: {}; }]>;
+}
+/** Description paragraph directive explaining the empty state. */
+declare class YuwEmptyDescriptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwEmptyDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwEmptyDescriptionDirective, "[yuwEmptyDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.HlmEmptyDescription; inputs: {}; outputs: {}; }]>;
+}
+/** Content slot directive for action buttons or call-to-action controls in an empty state. */
+declare class YuwEmptyContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwEmptyContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwEmptyContentDirective, "[yuwEmptyContent]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.HlmEmptyContent; inputs: {}; outputs: {}; }]>;
+}
+/** Every empty-state part, for a consumer's `imports`. */
+declare const YuwEmptyImports: readonly [typeof YuwEmptyDirective, typeof YuwEmptyHeaderDirective, typeof YuwEmptyMediaDirective, typeof YuwEmptyTitleDirective, typeof YuwEmptyDescriptionDirective, typeof YuwEmptyContentDirective];
+
+/**
+ * Checkmark shown at the trailing edge of a `[yuwContextMenuCheckbox]` item while it is checked.
+ *
+ * Place it inside the checkbox item; the helm indicator positions itself absolutely against the
+ * item and only becomes visible when the item carries `data-checked`.
+ *
+ * Usage:
+ * ```html
+ * <button yuwContextMenuCheckbox [checked]="showArchived()" (triggered)="toggleArchived()">
+ *   Show archived
+ *   <yuw-context-menu-checkbox-indicator />
+ * </button>
+ * ```
+ */
+declare class YuwContextMenuCheckboxIndicatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuCheckboxIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwContextMenuCheckboxIndicatorComponent, "yuw-context-menu-checkbox-indicator", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Mark shown at the trailing edge of a `[yuwContextMenuRadio]` item while it is selected.
+ *
+ * Place it inside the radio item; the helm indicator positions itself absolutely against the
+ * item and only becomes visible when the item carries `data-checked`.
+ *
+ * Usage:
+ * ```html
+ * <button yuwContextMenuRadio [checked]="order() === 'asc'" (triggered)="setOrder('asc')">
+ *   Ascending
+ *   <yuw-context-menu-radio-indicator />
+ * </button>
+ * ```
+ */
+declare class YuwContextMenuRadioIndicatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuRadioIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwContextMenuRadioIndicatorComponent, "yuw-context-menu-radio-indicator", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Trailing chevron for a `[yuwContextMenuSubTrigger]` item, signalling that it opens a nested
+ * sub-menu. Flips automatically in RTL layouts.
+ *
+ * Usage:
+ * ```html
+ * <button [yuwContextMenuSubTrigger]="subMenu">
+ *   More tools
+ *   <yuw-context-menu-sub-indicator />
+ * </button>
+ * ```
+ */
+declare class YuwContextMenuSubIndicatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuSubIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwContextMenuSubIndicatorComponent, "yuw-context-menu-sub-indicator", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Context menu directives suite based on right-click actions and panel controls.
+ *
+ * Why some inputs/outputs below are bridged imperatively instead of forwarded via
+ * `hostDirectives`: Angular only lets a wrapper re-expose a host directive's *own* (or
+ * class-inherited) inputs/outputs. Names the helm layer itself only *exposes* from its own host
+ * directives (`hlmContextMenuTrigger`, `hlmContextMenuOpened`/`hlmContextMenuClosed`, the items'
+ * `checked`/`disabled`/`keepOpen`/`triggered`) are not re-exposable one level further — the
+ * compiler rejects the mapping with NG2017 ("does not have an input with a public name of …"),
+ * and the runtime's `validateMappings` enforces the same rule. Verified against Angular 21.2
+ * (`validateHostDirectiveMappings` in the compiler, `validateMappings` in core) and reproduced
+ * with an isolated `ngc` compile. Own inputs of the helm classes (`disabled`/`align`/`side` on
+ * the trigger, `inset`/`variant` on items, `sideOffset` on the panel) *are* forwarded
+ * declaratively.
+ */
+/**
+ * Attach to an element to open a context menu upon right-clicking.
+ *
+ * Usage:
+ * ```html
+ * <div [yuwContextMenuTrigger]="menu">Right-click me</div>
+ *
+ * <ng-template #menu>
+ *   <div yuwContextMenu>
+ *     <button yuwContextMenuItem (triggered)="onEdit()">Edit</button>
+ *     <button yuwContextMenuItem variant="destructive" (triggered)="onDelete()">Delete</button>
+ *   </div>
+ * </ng-template>
+ * ```
+ */
+declare class YuwContextMenuTriggerDirective {
+    private readonly _trigger;
+    readonly menu: _angular_core.InputSignal<TemplateRef<unknown>>;
+    readonly menuData: _angular_core.InputSignal<unknown>;
+    readonly opened: _angular_core.OutputRef<void>;
+    readonly closed: _angular_core.OutputRef<void>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuTriggerDirective, "[yuwContextMenuTrigger]", never, { "menu": { "alias": "yuwContextMenuTrigger"; "required": true; "isSignal": true; }; "menuData": { "alias": "yuwContextMenuTriggerData"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, [{ directive: typeof i1$4.HlmContextMenuTrigger; inputs: { "disabled": "disabled"; "align": "align"; "side": "side"; }; outputs: {}; }]>;
+}
+/** Container directive for context menu options, placed inside the context menu template. */
+declare class YuwContextMenuDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuDirective, "[yuwContextMenu]", never, {}, {}, never, never, true, [{ directive: typeof i2.HlmDropdownMenu; inputs: { "sideOffset": "sideOffset"; }; outputs: {}; }]>;
+}
+/** Interactive action item within a context menu. Place on a `<button>` element. */
+declare class YuwContextMenuItemDirective {
+    private readonly _item;
+    readonly triggered: _angular_core.OutputRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuItemDirective, "[yuwContextMenuItem]", never, {}, { "triggered": "triggered"; }, never, never, true, [{ directive: typeof i2.HlmDropdownMenuItem; inputs: { "disabled": "disabled"; "variant": "variant"; "inset": "inset"; }; outputs: {}; }]>;
+}
+/**
+ * Checkable action item within a context menu. Place on a `<button>` element and project a
+ * `<yuw-context-menu-checkbox-indicator />` to show the checkmark while checked.
+ *
+ * Toggling keeps the menu open (the helm default). The `checked` input drives the state; listen
+ * to `triggered` to flip it in the consumer.
+ *
+ * Usage:
+ * ```html
+ * <button yuwContextMenuCheckbox [checked]="showArchived()" (triggered)="toggleArchived()">
+ *   Show archived
+ *   <yuw-context-menu-checkbox-indicator />
+ * </button>
+ * ```
+ */
+declare class YuwContextMenuCheckboxDirective {
+    private readonly _item;
+    readonly checked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly triggered: _angular_core.OutputRef<void>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuCheckboxDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuCheckboxDirective, "[yuwContextMenuCheckbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "triggered": "triggered"; }, never, never, true, [{ directive: typeof i2.HlmDropdownMenuCheckbox; inputs: { "inset": "inset"; }; outputs: {}; }]>;
+}
+/**
+ * Single-select (radio) item within a context menu. Place on a `<button>` element inside a
+ * `[yuwContextMenuGroup]` and project a `<yuw-context-menu-radio-indicator />` to show the mark
+ * while selected.
+ *
+ * Selecting keeps the menu open (the helm default). The `checked` input drives the state; listen
+ * to `triggered` to set it in the consumer.
+ *
+ * Usage:
+ * ```html
+ * <div yuwContextMenuGroup>
+ *   <button yuwContextMenuRadio [checked]="order() === 'asc'" (triggered)="setOrder('asc')">
+ *     Ascending
+ *     <yuw-context-menu-radio-indicator />
+ *   </button>
+ * </div>
+ * ```
+ */
+declare class YuwContextMenuRadioDirective {
+    private readonly _item;
+    readonly checked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly triggered: _angular_core.OutputRef<void>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuRadioDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuRadioDirective, "[yuwContextMenuRadio]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "triggered": "triggered"; }, never, never, true, [{ directive: typeof i2.HlmDropdownMenuRadio; inputs: {}; outputs: {}; }]>;
+}
+/** Section heading/label within a context menu. */
+declare class YuwContextMenuLabelDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuLabelDirective, "[yuwContextMenuLabel]", never, {}, {}, never, never, true, [{ directive: typeof i2.HlmDropdownMenuLabel; inputs: { "inset": "inset"; }; outputs: {}; }]>;
+}
+/** Group container for grouping context menu items (required around `[yuwContextMenuRadio]` sets). */
+declare class YuwContextMenuGroupDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuGroupDirective, "[yuwContextMenuGroup]", never, {}, {}, never, never, true, [{ directive: typeof i2.HlmDropdownMenuGroup; inputs: {}; outputs: {}; }]>;
+}
+/** Visual divider line between context menu items. */
+declare class YuwContextMenuSeparatorDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuSeparatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuSeparatorDirective, "[yuwContextMenuSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i2.HlmDropdownMenuSeparator; inputs: {}; outputs: {}; }]>;
+}
+/** Text hint for a keyboard shortcut displayed alongside a context menu item. */
+declare class YuwContextMenuShortcutDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuShortcutDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuShortcutDirective, "[yuwContextMenuShortcut]", never, {}, {}, never, never, true, [{ directive: typeof i2.HlmDropdownMenuShortcut; inputs: {}; outputs: {}; }]>;
+}
+/** Container directive for nesting a sub-level context menu. */
+declare class YuwContextMenuSubDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuSubDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuSubDirective, "[yuwContextMenuSub]", never, {}, {}, never, never, true, [{ directive: typeof i2.HlmDropdownMenuSub; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Trigger item for expanding a nested sub-context menu.
+ *
+ * Usage:
+ * ```html
+ * <button [yuwContextMenuSubTrigger]="subMenu">
+ *   More tools
+ *   <yuw-context-menu-sub-indicator />
+ * </button>
+ * ```
+ */
+declare class YuwContextMenuSubTriggerDirective {
+    private readonly _trigger;
+    readonly menu: _angular_core.InputSignal<TemplateRef<unknown>>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwContextMenuSubTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwContextMenuSubTriggerDirective, "[yuwContextMenuSubTrigger]", never, { "menu": { "alias": "yuwContextMenuSubTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i2.HlmDropdownMenuSubTrigger; inputs: { "align": "align"; "side": "side"; }; outputs: {}; }]>;
+}
+/** Every context-menu part, for a consumer's `imports`. */
+declare const YuwContextMenuImports: readonly [typeof YuwContextMenuTriggerDirective, typeof YuwContextMenuDirective, typeof YuwContextMenuItemDirective, typeof YuwContextMenuCheckboxDirective, typeof YuwContextMenuCheckboxIndicatorComponent, typeof YuwContextMenuRadioDirective, typeof YuwContextMenuRadioIndicatorComponent, typeof YuwContextMenuLabelDirective, typeof YuwContextMenuGroupDirective, typeof YuwContextMenuSeparatorDirective, typeof YuwContextMenuShortcutDirective, typeof YuwContextMenuSubDirective, typeof YuwContextMenuSubTriggerDirective, typeof YuwContextMenuSubIndicatorComponent];
+
+type YuwDatepickerValue = Date | [Date, Date] | Date[] | null;
+type YuwDatepickerModeDto = 'single' | 'range' | 'multiple' | 'monthYear';
+/**
+ * Date picker control supporting single date, date range, multiple dates, or month/year pick modes.
+ *
+ * Inputs / Models:
+ * - `mode`: Selection mode (`'single'`, `'range'`, `'multiple'`, `'monthYear'`). Default is `'single'`.
+ * - `value`: Two-way selected date(s) (`YuwDatepickerValue`). Shape follows `mode`. Emits
+ *   `valueChange` on every selection change.
+ * - `disabled`: Disables the control.
+ * - `placeholder`: Text shown on the trigger while nothing is selected.
+ * - `minDate`: Earliest selectable date.
+ * - `maxDate`: Latest selectable date.
+ * - `captionLayout`: Calendar caption mode — `'dropdown'` adds month/year dropdowns for faster year navigation. Default is `'label'`.
+ *   Ignored in `monthYear` mode: that picker renders its own month/year grid and has no calendar caption.
+ * - `align`: Popover alignment relative to trigger (`'start'`, `'center'`, `'end'`). Default is `'start'`.
+ * - `buttonId`: HTML `id` for the trigger button, enabling external `<label for="...">`
+ *   association. When omitted, a unique per-instance id is generated.
+ * - `class`: Extra classes merged onto the trigger button (e.g. a width), consumer classes win.
+ * - `invalid`: Forces invalid styling.
+ * - `formatDate`: Custom date formatter function `(date: Date) => string` for the trigger label.
+ *   In `range`/`multiple` modes it formats each date, joined with `' - '` / `', '`.
+ *
+ * Usage:
+ * ```html
+ * <yuw-datepicker [(value)]="selectedDate" placeholder="Select date..." />
+ * <yuw-datepicker mode="range" [(value)]="dateRange" />
+ * <yuw-datepicker mode="monthYear" [(value)]="selectedMonth" />
+ * ```
+ */
+declare class YuwDatepickerComponent extends YuwValueAccessorBase<YuwDatepickerValue> {
+    readonly mode: _angular_core.InputSignal<YuwDatepickerModeDto>;
+    readonly value: _angular_core.ModelSignal<YuwDatepickerValue>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly minDate: _angular_core.InputSignal<Date | undefined>;
+    readonly maxDate: _angular_core.InputSignal<Date | undefined>;
+    readonly captionLayout: _angular_core.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
+    readonly buttonId: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly formatDate: _angular_core.InputSignal<((date: Date) => string) | undefined>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    private readonly _generatedButtonId;
+    protected readonly _buttonId: _angular_core.Signal<string>;
+    private readonly _singleConfig;
+    private readonly _rangeConfig;
+    private readonly _multiConfig;
+    private readonly _monthYearConfig;
+    protected readonly _formatSingle: _angular_core.Signal<(date: Date) => string>;
+    protected readonly _formatMonthYear: _angular_core.Signal<(date: Date) => string>;
+    protected readonly _formatRange: _angular_core.Signal<(dates: [Date | null, Date | null]) => string>;
+    protected readonly _formatMulti: _angular_core.Signal<(dates: Date[]) => string>;
+    protected readonly _singleValue: _angular_core.Signal<Date | undefined>;
+    protected readonly _rangeValue: _angular_core.Signal<[Date, Date] | undefined>;
+    protected readonly _multipleValue: _angular_core.Signal<Date[]>;
+    protected _emptyValue(): YuwDatepickerValue;
+    protected onValueChange(next: YuwDatepickerValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwDatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwDatepickerComponent, "yuw-datepicker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "buttonId": { "alias": "buttonId"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "formatDate": { "alias": "formatDate"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Outer wrapper container directive for responsive HTML table scroll container.
+ *
+ * Usage:
+ * ```html
+ * <div yuwTableContainer>
+ *   <table yuwTable>
+ *     <thead yuwTHead>
+ *       <tr yuwTr><th yuwTh>Header</th></tr>
+ *     </thead>
+ *     <tbody yuwTBody>
+ *       <tr yuwTr><td yuwTd>Data cell</td></tr>
+ *     </tbody>
+ *   </table>
+ * </div>
+ * ```
+ */
+declare class YuwTableContainerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTableContainerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTableContainerDirective, "[yuwTableContainer]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTableContainer; inputs: {}; outputs: {}; }]>;
+}
+/** Table element styling directive applied to native `<table>`. */
+declare class YuwTableDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTableDirective, "[yuwTable]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTable; inputs: {}; outputs: {}; }]>;
+}
+/** Table header container directive applied to native `<thead>`. */
+declare class YuwTHeadDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTHeadDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTHeadDirective, "[yuwTHead]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTHead; inputs: {}; outputs: {}; }]>;
+}
+/** Table body container directive applied to native `<tbody>`. */
+declare class YuwTBodyDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTBodyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTBodyDirective, "[yuwTBody]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTBody; inputs: {}; outputs: {}; }]>;
+}
+/** Table footer container directive applied to native `<tfoot>`. */
+declare class YuwTFootDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTFootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTFootDirective, "[yuwTFoot]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTFoot; inputs: {}; outputs: {}; }]>;
+}
+/** Table row directive applied to native `<tr>`. */
+declare class YuwTrDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTrDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTrDirective, "[yuwTr]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTr; inputs: {}; outputs: {}; }]>;
+}
+/** Table header cell directive applied to native `<th>`. */
+declare class YuwThDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwThDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwThDirective, "[yuwTh]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTh; inputs: {}; outputs: {}; }]>;
+}
+/** Table data cell directive applied to native `<td>`. */
+declare class YuwTdDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTdDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTdDirective, "[yuwTd]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmTd; inputs: {}; outputs: {}; }]>;
+}
+/** Table caption directive applied to native `<caption>`. */
+declare class YuwCaptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwCaptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwCaptionDirective, "[yuwCaption]", never, {}, {}, never, never, true, [{ directive: typeof i1$5.HlmCaption; inputs: {}; outputs: {}; }]>;
+}
+/** Every table part, for a consumer's `imports`. */
+declare const YuwTableImports: readonly [typeof YuwTableContainerDirective, typeof YuwTableDirective, typeof YuwTHeadDirective, typeof YuwTBodyDirective, typeof YuwTFootDirective, typeof YuwTrDirective, typeof YuwThDirective, typeof YuwTdDirective, typeof YuwCaptionDirective];
+
+/**
+ * The feature set `yuw-datatable` enables.
+ *
+ * Declared as an interface keyed by feature name rather than `typeof` an object literal: TanStack
+ * v9 types every feature constant as a bare `TableFeature`, and carries the *capabilities* on the
+ * key names instead (see its own `StockFeatures`). A `typeof` would therefore widen every entry to
+ * `TableFeature` and lose which features are actually on, leaving the table's own methods
+ * (`getState`, `getCanNextPage`, …) missing from the instance type.
+ */
+interface YuwDatatableFeatures {
+    columnFilteringFeature: typeof columnFilteringFeature;
+    columnVisibilityFeature: typeof columnVisibilityFeature;
+    rowPaginationFeature: typeof rowPaginationFeature;
+    rowSelectionFeature: typeof rowSelectionFeature;
+    rowSortingFeature: typeof rowSortingFeature;
+}
+declare const YUW_DATATABLE_FEATURES: YuwDatatableFeatures;
+type YuwDatatableColumnDef<TData extends RowData> = ColumnDef<YuwDatatableFeatures, TData>;
+/**
+ * Full-featured data table component supporting sorting, filtering, pagination, row selection,
+ * loading skeleton state, and column visibility.
+ *
+ * Inputs / Models:
+ * - `columns`: Column definitions array (`YuwDatatableColumnDef<TData>[]`). Default is `[]`.
+ * - `data`: Row data array (`TData[]`). Default is `[]`.
+ * - `sortable`: Enables click-to-sort on headers whose column allows it.
+ * - `paginated`: Enables the pagination row model and renders footer controls.
+ * - `selectable`: Enables the row-selection state. The checkbox column itself is *not* rendered
+ *   by the datatable — the consumer provides it as a display column (`id: 'select'`,
+ *   `flexRenderComponent(...)` header/cell that call TanStack's own toggle handlers), as in the
+ *   demo's data page.
+ * - `emptyText`: Message shown when data is empty or filtered to nothing. User-facing text the
+ *   consuming app is responsible for translating.
+ * - `loading`: Renders skeleton rows instead of data. The pagination footer stays visible (with
+ *   its buttons disabled) so the layout doesn't jump.
+ * - `loadingRows`: Number of skeleton rows to show while `loading`. Default is `5`.
+ * - `previousPageLabel` (required): Accessible name for the footer's previous-page button.
+ *   User-facing text the consuming app is responsible for translating.
+ * - `nextPageLabel` (required): Accessible name for the footer's next-page button. User-facing
+ *   text the consuming app is responsible for translating.
+ * - `caption`: Optional `<caption>` text for the table. User-facing text the consuming app is
+ *   responsible for translating; when absent, no caption is rendered.
+ * - `tableClass`: Extra classes merged onto the inner `<table>` element. The host is
+ *   `display: contents`, so a plain `class` on `<yuw-datatable>` would never reach the table.
+ * - `sorting`: Two-way sorting state (`SortingState`).
+ * - `columnFilters`: Two-way column filters state (`ColumnFiltersState`).
+ * - `columnVisibility`: Two-way column visibility state (`ColumnVisibilityState`).
+ * - `rowSelection`: Two-way row selection state (`RowSelectionState`).
+ * - `pagination`: Two-way pagination state (`PaginationState`). Default is `{ pageIndex: 0, pageSize: 10 }`.
+ *
+ * Outputs:
+ * - `selectedRowsChange`: Emits the selected row objects (`TData[]`) on selection changes. The
+ *   initial state does not emit — only actual changes after mount.
+ *
+ * Usage:
+ * ```html
+ * <yuw-datatable
+ *   [columns]="columns"
+ *   [data]="users"
+ *   [(sorting)]="sorting"
+ *   paginated
+ *   selectable
+ *   previousPageLabel="Página anterior"
+ *   nextPageLabel="Página siguiente"
+ *   (selectedRowsChange)="onSelect($event)"
+ * />
+ * ```
+ */
+declare class YuwDatatableComponent<TData extends RowData> implements OnInit {
+    readonly columns: _angular_core.InputSignal<YuwDatatableColumnDef<TData>[]>;
+    readonly data: _angular_core.InputSignal<TData[]>;
+    readonly sortable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly paginated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyText: _angular_core.InputSignal<string | undefined>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loadingRows: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly previousPageLabel: _angular_core.InputSignal<string>;
+    readonly nextPageLabel: _angular_core.InputSignal<string>;
+    readonly caption: _angular_core.InputSignal<string | undefined>;
+    readonly tableClass: _angular_core.InputSignal<string | undefined>;
+    readonly sorting: _angular_core.ModelSignal<SortingState>;
+    readonly columnFilters: _angular_core.ModelSignal<ColumnFiltersState>;
+    readonly columnVisibility: _angular_core.ModelSignal<ColumnVisibilityState>;
+    readonly rowSelection: _angular_core.ModelSignal<RowSelectionState>;
+    readonly pagination: _angular_core.ModelSignal<PaginationState>;
+    private readonly _options;
+    protected readonly table: _tanstack_angular_table.AngularTable<YuwDatatableFeatures, TData>;
+    private readonly _selectedRows;
+    readonly selectedRowsChange: _angular_core.OutputRef<TData[]>;
+    /**
+     * Applies the real options once, after inputs are set.
+     *
+     * `injectTable` constructs the table from a `queueMicrotask` that can fire before Angular has
+     * assigned any input, so it captures `columns: []`/`data: []`. Its own options effect then
+     * *skips its first run* (an `isMount` guard inside the library) — and that skipped run is
+     * exactly the one carrying the real values. Without this the table stays permanently empty no
+     * matter what is bound.
+     *
+     * This runs in `ngOnInit` rather than a constructor `effect` because the effect fires in the
+     * same too-early window and re-applies the same empty options; `ngOnInit` is the first point
+     * where inputs are guaranteed present. Later changes are handled by the library's own effect,
+     * which by then is past its mount guard.
+     */
+    ngOnInit(): void;
+    protected readonly _isEmpty: _angular_core.Signal<boolean>;
+    protected readonly _columnCount: _angular_core.Signal<number>;
+    protected readonly _skeletonRows: _angular_core.Signal<number[]>;
+    protected readonly _tableClass: _angular_core.Signal<string>;
+    protected readonly _ariaSort: Record<'asc' | 'desc', 'ascending' | 'descending'>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwDatatableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwDatatableComponent<any>, "yuw-datatable", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "paginated": { "alias": "paginated"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingRows": { "alias": "loadingRows"; "required": false; "isSignal": true; }; "previousPageLabel": { "alias": "previousPageLabel"; "required": true; "isSignal": true; }; "nextPageLabel": { "alias": "nextPageLabel"; "required": true; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "tableClass": { "alias": "tableClass"; "required": false; "isSignal": true; }; "sorting": { "alias": "sorting"; "required": false; "isSignal": true; }; "columnFilters": { "alias": "columnFilters"; "required": false; "isSignal": true; }; "columnVisibility": { "alias": "columnVisibility"; "required": false; "isSignal": true; }; "rowSelection": { "alias": "rowSelection"; "required": false; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": false; "isSignal": true; }; }, { "sorting": "sortingChange"; "columnFilters": "columnFiltersChange"; "columnVisibility": "columnVisibilityChange"; "rowSelection": "rowSelectionChange"; "pagination": "paginationChange"; "selectedRowsChange": "selectedRowsChange"; }, never, never, true, never>;
+}
+
+/** A single entry in `<yuw-avatar>`'s `group` input, which turns it into a stack of overlapping avatars. */
+interface YuwAvatarGroupItemDto {
+    alt: string;
+    src?: string;
+    fallback: string;
+}
+
+/** The size vocabulary of `<yuw-avatar>`. */
+type YuwAvatarSizeDto = 'default' | 'sm' | 'lg';
+/**
+ * Displays a user or entity avatar with optional image, fallback text/initials, status badge, or overlapping group layout.
+ *
+ * Inputs:
+ * - `size`: Avatar size (`'default'`, `'sm'`, `'lg'`). Default is `'default'`.
+ * - `src`: Image URL for single-avatar mode. Omit to display fallback text.
+ * - `alt`: Required. Accessible label for single-avatar mode and fallback text. User-facing text —
+ *   the consuming app is responsible for providing (and translating) it.
+ * - `fallback`: Fallback text or initials shown when image is loading, unprovided, or fails to load.
+ * - `badge`: Renders a status badge marker on the bottom-right corner (single-avatar mode).
+ * - `group`: Array of item DTOs (`YuwAvatarGroupItemDto[]`) to render as an overlapping avatar group stack.
+ * - `groupCount`: Overflow label string (e.g. `"+5"`) displayed at the end of an avatar group stack.
+ * - `class`: Extra CSS classes merged onto the inner `hlm-avatar` element(s); merged last, so they win.
+ *
+ * Single Avatar Usage:
+ * ```html
+ * <yuw-avatar src="/path/to/user.png" alt="Jane Doe" fallback="JD" />
+ * <yuw-avatar alt="Jane Doe" fallback="JD" badge />
+ * ```
+ *
+ * Avatar Group Usage:
+ * ```html
+ * <yuw-avatar [group]="teamMembers" alt="Team" groupCount="+5" />
+ * ```
+ */
+declare class YuwAvatarComponent {
+    readonly size: _angular_core.InputSignal<YuwAvatarSizeDto>;
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly fallback: _angular_core.InputSignal<string | undefined>;
+    readonly badge: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly group: _angular_core.InputSignal<YuwAvatarGroupItemDto[] | undefined>;
+    readonly groupCount: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    protected readonly _isGroup: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwAvatarComponent, "yuw-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": true; "isSignal": true; }; "fallback": { "alias": "fallback"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "group": { "alias": "group"; "required": false; "isSignal": true; }; "groupCount": { "alias": "groupCount"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["[yuwAvatarBadgeIcon]"], true, never>;
+}
+
+/**
+ * Container directive for list/row item layout structures.
+ * Accepts optional `variant` and `size` inputs.
+ *
+ * Usage:
+ * ```html
+ * <div yuwItem>
+ *   <div yuwItemMedia><yuw-avatar fallback="JD" alt="John Doe" /></div>
+ *   <div yuwItemContent>
+ *     <h4 yuwItemTitle>John Doe</h4>
+ *     <p yuwItemDescription>Software Engineer</p>
+ *   </div>
+ *   <div yuwItemActions><yuw-button size="sm">Follow</yuw-button></div>
+ * </div>
+ * ```
+ */
+declare class YuwItemDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemDirective, "[yuwItem], yuw-item", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItem; inputs: { "variant": "variant"; "size": "size"; }; outputs: {}; }]>;
+}
+/** Header slot directive for an item container. */
+declare class YuwItemHeaderDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemHeaderDirective, "[yuwItemHeader], yuw-item-header", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemHeader; inputs: {}; outputs: {}; }]>;
+}
+/** Leading media slot directive (for icons, avatars, or images) at the start of an item. Supports `variant` (`'default'`, `'icon'`, `'image'`). */
+declare class YuwItemMediaDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemMediaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemMediaDirective, "[yuwItemMedia], yuw-item-media", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemMedia; inputs: { "variant": "variant"; }; outputs: {}; }]>;
+}
+/** Main text content container directive for an item. */
+declare class YuwItemContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemContentDirective, "[yuwItemContent], yuw-item-content", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemContent; inputs: {}; outputs: {}; }]>;
+}
+/** Title heading directive for an item. */
+declare class YuwItemTitleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemTitleDirective, "[yuwItemTitle], yuw-item-title", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemTitle; inputs: {}; outputs: {}; }]>;
+}
+/** Subtitle or description paragraph directive for an item. */
+declare class YuwItemDescriptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemDescriptionDirective, "[yuwItemDescription], yuw-item-description", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemDescription; inputs: {}; outputs: {}; }]>;
+}
+/** Trailing action controls slot directive (for buttons, switches, or menu triggers) at the end of an item. */
+declare class YuwItemActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemActionsDirective, "[yuwItemActions], yuw-item-actions", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemActions; inputs: {}; outputs: {}; }]>;
+}
+/** Footer slot directive for an item. */
+declare class YuwItemFooterDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemFooterDirective, "[yuwItemFooter], yuw-item-footer", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemFooter; inputs: {}; outputs: {}; }]>;
+}
+/** Container directive for grouping multiple item rows together into a list card or bordered group. */
+declare class YuwItemGroupDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemGroupDirective, "[yuwItemGroup], yuw-item-group", never, {}, {}, never, never, true, [{ directive: typeof i1$6.HlmItemGroup; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Visual separator line between items inside a group. Accepts `orientation` (`'horizontal'` or
+ * `'vertical'`), reaching the underlying `BrnSeparator`, which owns the `role`,
+ * `aria-orientation` and `data-orientation` attributes. Extends `HlmItemSeparator` (instead of
+ * composing it via `hostDirectives`) because `orientation` is re-exposed by the helm from
+ * `BrnSeparator` through its own `hostDirectives`, and host-directive forwarding is not
+ * transitive (NG2017).
+ */
+declare class YuwItemSeparatorDirective extends HlmItemSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwItemSeparatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwItemSeparatorDirective, "[yuwItemSeparator], yuw-item-separator", never, {}, {}, never, never, true, never>;
+}
+/** Every item part, for a consumer's `imports`. */
+declare const YuwItemImports: readonly [typeof YuwItemDirective, typeof YuwItemHeaderDirective, typeof YuwItemMediaDirective, typeof YuwItemContentDirective, typeof YuwItemTitleDirective, typeof YuwItemDescriptionDirective, typeof YuwItemActionsDirective, typeof YuwItemFooterDirective, typeof YuwItemGroupDirective, typeof YuwItemSeparatorDirective];
+
+/**
+ * Marks an element as the sheet's footer content, projected into the footer slot.
+ * Its presence is also what makes the footer render at all — without it the sheet
+ * shows no empty footer strip.
+ */
+declare class YuwSheetFooterDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSheetFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSheetFooterDirective, "[yuwSheetFooter]", never, {}, {}, never, never, true, never>;
+}
+
+type YuwSheetSideDto = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Slide-in sheet overlay panel component for side drawers, dialogs, and detail views.
+ *
+ * Accessibility: provide either `title` or `ariaLabel` — a modal panel without an accessible name
+ * is announced as an anonymous dialog by screen readers.
+ *
+ * Inputs / Models:
+ * - `open`: Two-way open/closed state (`boolean`). Drive directly via `[(open)]` to open/close programmatically.
+ * - `showTrigger`: Whether to render the trigger button. Set `false` when opening only via `[(open)]`.
+ * - `side`: Edge of the screen the panel slides in from (`'top'`, `'bottom'`, `'left'`, `'right'`). Default is `'right'`.
+ * - `title`: Optional header title text. User-facing text the consuming app is responsible for translating.
+ * - `description`: Optional header description text. User-facing text the consuming app is responsible for translating.
+ * - `ariaLabel`: Accessible name for the sheet when no visible `title` is rendered. User-facing
+ *   text the consuming app is responsible for translating.
+ * - `closeLabel`: Accessible label of the corner close (×) button. When set, the close button
+ *   renders and screen readers read this label; when absent there is no close button. User-facing
+ *   text the consuming app is responsible for translating.
+ * - `panelClass`: Extra classes merged onto the sheet panel (e.g. `sm:max-w-lg` to widen it).
+ *   They win over the library defaults via `twMerge`.
+ * - `triggerVariant`: Button style variant for the trigger button.
+ * - `triggerSize`: Button size for the trigger button.
+ *
+ * Usage:
+ * ```html
+ * <yuw-sheet [(open)]="isOpen" side="right" title="Edit Profile" description="Update your account details." closeLabel="Close">
+ *   <ng-container yuwSheetTrigger>Edit Profile</ng-container>
+ *
+ *   <p>Sheet form content goes here.</p>
+ *
+ *   <div yuwSheetFooter>
+ *     <yuw-button (clicked)="save()">Save Changes</yuw-button>
+ *   </div>
+ * </yuw-sheet>
+ * ```
+ */
+declare class YuwSheetComponent {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly showTrigger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly side: _angular_core.InputSignal<YuwSheetSideDto>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly closeLabel: _angular_core.InputSignal<string | undefined>;
+    readonly panelClass: _angular_core.InputSignal<string | undefined>;
+    readonly triggerVariant: _angular_core.InputSignal<"secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined>;
+    readonly triggerSize: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    protected readonly hasFooter: _angular_core.Signal<YuwSheetFooterDirective | undefined>;
+    protected readonly _sheetState: _angular_core.Signal<"open" | "closed">;
+    protected onStateChanged(state: 'open' | 'closed'): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSheetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwSheetComponent, "yuw-sheet", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "showTrigger": { "alias": "showTrigger"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "triggerVariant": { "alias": "triggerVariant"; "required": false; "isSignal": true; }; "triggerSize": { "alias": "triggerSize"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, ["hasFooter"], ["[yuwSheetTrigger]", "*", "[yuwSheetFooter]"], true, never>;
+}
+declare const YuwSheetImports: readonly [typeof YuwSheetComponent, typeof YuwSheetFooterDirective];
+
+type YuwPopoverAlignDto = 'start' | 'center' | 'end';
+/**
+ * Popover component for displaying anchored floating overlay panels.
+ *
+ * Inputs / Models:
+ * - `open`: Two-way open/closed state (`boolean`). Drive directly via `[(open)]` to open/close programmatically.
+ * - `showTrigger`: Whether to render the trigger button. Set `false` when opening only via `[(open)]`.
+ * - `align`: Panel alignment relative to trigger (`'start'`, `'center'`, `'end'`). Default is `'center'`.
+ * - `sideOffset`: Pixel offset between the trigger and the panel. Default is `4`.
+ * - `title`: Optional header title text. User-facing text the consuming app is responsible for translating.
+ * - `description`: Optional header description text. User-facing text the consuming app is responsible for translating.
+ * - `panelClass`: Extra classes merged onto the popover panel (e.g. `w-80` to widen it). They win
+ *   over the library defaults via `twMerge`.
+ * - `triggerVariant`: Button style variant for the trigger button.
+ * - `triggerSize`: Button size for the trigger button.
+ *
+ * Usage:
+ * ```html
+ * <yuw-popover [(open)]="isOpen" title="Notifications" description="You're all caught up.">
+ *   <ng-container yuwPopoverTrigger>View Notifications</ng-container>
+ *
+ *   <p>Popover content body goes here.</p>
+ * </yuw-popover>
+ * ```
+ */
+declare class YuwPopoverComponent {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly showTrigger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly align: _angular_core.InputSignal<YuwPopoverAlignDto>;
+    readonly sideOffset: _angular_core.InputSignal<number>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly panelClass: _angular_core.InputSignal<string | undefined>;
+    readonly triggerVariant: _angular_core.InputSignal<"secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined>;
+    readonly triggerSize: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    protected readonly _popoverState: _angular_core.Signal<"open" | "closed">;
+    protected onOpenChange(state: 'open' | 'closed'): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwPopoverComponent, "yuw-popover", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "showTrigger": { "alias": "showTrigger"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "triggerVariant": { "alias": "triggerVariant"; "required": false; "isSignal": true; }; "triggerSize": { "alias": "triggerSize"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["[yuwPopoverTrigger]", "*"], true, never>;
+}
+
+type YuwTooltipPositionDto = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Tooltip directive applied directly to the element that should show a hint on hover/focus.
+ *
+ * Inputs:
+ * - `yuwTooltip`: Tooltip text (or `TemplateRef`) to display. User-facing text the consuming app
+ *   is responsible for translating.
+ * - `position`: Side the tooltip opens on (`'top'`, `'bottom'`, `'left'`, `'right'`). Default is `'top'`.
+ * - `showDelay`: Milliseconds before the tooltip opens on hover. Defaults to the Brain tooltip
+ *   config default (`150`).
+ * - `hideDelay`: Milliseconds before the tooltip closes after the pointer leaves. Defaults to the
+ *   Brain tooltip config default (`100`).
+ * - `tooltipDisabled`: Disables the tooltip entirely.
+ *
+ * Usage:
+ * ```html
+ * <button yuwTooltip="Save changes" hlmBtn>Save</button>
+ * <yuw-button [yuwTooltip]="helpText" position="right">Help</yuw-button>
+ * ```
+ */
+declare class YuwTooltipDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTooltipDirective, "[yuwTooltip]", never, {}, {}, never, never, true, [{ directive: typeof i1$7.BrnTooltip; inputs: { "brnTooltip": "yuwTooltip"; "position": "position"; "hideDelay": "hideDelay"; "showDelay": "showDelay"; "tooltipDisabled": "tooltipDisabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * Indeterminate loading spinner.
+ *
+ * Inputs:
+ * - `label`: Accessible label announced by screen readers. User-facing text the consuming app is
+ *   responsible for translating.
+ * - `icon`: Name of a registered icon to spin instead of the default loader.
+ *
+ * Usage:
+ * ```html
+ * <yuw-spinner label="Cargando" />
+ * ```
+ */
+declare class YuwSpinnerComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwSpinnerComponent, "yuw-spinner", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type YuwToasterPositionDto = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+type YuwToasterThemeDto = 'light' | 'dark' | 'system';
+/**
+ * Global toast host. Mount once near the application root; individual toasts are dispatched
+ * through the `toast` API from `@spartan-ng/brain/sonner`.
+ *
+ * Inputs:
+ * - `richColors`: Enables per-type colored toasts (success, error, warning, info). Enabled by
+ *   default — a deliberate deviation from the spartan default (`false`).
+ * - `theme`: Toast color theme (`'light'`, `'dark'`, `'system'`). Default is `'light'` (the helm
+ *   default) — apps rendering in dark mode must pass `'dark'` (or `'system'`) explicitly.
+ * - `toastOptions`: Default options applied to every toast (classes, styles, etc.), passed
+ *   through to the underlying sonner toaster.
+ * - `position`: Screen corner the stack renders in. Default is `'bottom-right'`.
+ * - `duration`: Milliseconds a toast stays visible. Default is `4000`.
+ * - `visibleToasts`: Maximum simultaneously visible toasts. Default is `3`.
+ * - `closeButton`: Renders a dismiss button on each toast.
+ * - `expand`: Keeps the stack expanded instead of collapsed.
+ *
+ * Usage:
+ * ```html
+ * <yuw-toaster />
+ * ```
+ */
+declare class YuwToasterComponent {
+    readonly richColors: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly theme: _angular_core.InputSignal<YuwToasterThemeDto>;
+    readonly toastOptions: _angular_core.InputSignal<ToastOptions>;
+    readonly position: _angular_core.InputSignal<YuwToasterPositionDto>;
+    readonly duration: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly visibleToasts: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly closeButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly expand: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwToasterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwToasterComponent, "yuw-toaster", never, { "richColors": { "alias": "richColors"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "toastOptions": { "alias": "toastOptions"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "visibleToasts": { "alias": "visibleToasts"; "required": false; "isSignal": true; }; "closeButton": { "alias": "closeButton"; "required": false; "isSignal": true; }; "expand": { "alias": "expand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Marks a projected element as the trailing action of a `<yuw-alert>`, which pins it to the
+ * top-right corner of the alert.
+ */
+declare class YuwAlertActionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAlertActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAlertActionDirective, "[yuwAlertAction]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks projected rich content (links, `<strong>`, …) as the description of a `<yuw-alert>`.
+ *
+ * When present, the alert projects this content into its description slot instead of rendering
+ * the `description` string input. The content lands inside the element carrying the helm
+ * `alert-description` data-slot, so the alert's grid keeps positioning it correctly.
+ */
+declare class YuwAlertDescriptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAlertDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAlertDescriptionDirective, "[yuwAlertDescription]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks projected rich content (links, `<strong>`, …) as the title of a `<yuw-alert>`.
+ *
+ * When present, the alert projects this content into its title slot instead of rendering the
+ * `title` string input. The content lands inside the element carrying the helm `alert-title`
+ * data-slot, so the alert's grid keeps positioning it correctly.
+ */
+declare class YuwAlertTitleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAlertTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAlertTitleDirective, "[yuwAlertTitle]", never, {}, {}, never, never, true, never>;
+}
+
+type YuwAlertVariantDto = 'default' | 'destructive';
+/**
+ * Inline, non-blocking message panel for status and validation feedback.
+ *
+ * Inputs:
+ * - `variant`: Visual tone (`'default'`, `'destructive'`). Default is `'default'`.
+ * - `title`: Heading text. User-facing text the consuming app is responsible for translating.
+ *   Ignored when a `[yuwAlertTitle]` slot is projected.
+ * - `description`: Body text. User-facing text the consuming app is responsible for translating.
+ *   Ignored when a `[yuwAlertDescription]` slot is projected.
+ * - `class`: Classes forwarded to the inner `hlm-alert` panel (the host is `display: contents`,
+ *   so they would otherwise never reach the rendered element). The consumer's classes win over
+ *   the alert's own styling.
+ *
+ * Content slots:
+ * - `[yuwAlertIcon]`: Leading icon.
+ * - `[yuwAlertTitle]`: Rich title content (links, `<strong>`, …). Replaces the `title` input.
+ * - `[yuwAlertDescription]`: Rich description content. Replaces the `description` input.
+ * - `[yuwAlertAction]`: Trailing action control, pinned to the top-right corner.
+ *
+ * Usage:
+ * ```html
+ * <yuw-alert variant="destructive" title="Pago rechazado" description="Revisa los datos de la tarjeta.">
+ *   <ng-icon yuwAlertIcon name="lucideTriangleAlert" />
+ *   <yuw-button yuwAlertAction size="sm" variant="ghost">Reintentar</yuw-button>
+ * </yuw-alert>
+ *
+ * <yuw-alert>
+ *   <span yuwAlertTitle>Condiciones <strong>actualizadas</strong></span>
+ *   <span yuwAlertDescription>Consulta los <a href="/cambios">cambios</a> antes de continuar.</span>
+ * </yuw-alert>
+ * ```
+ */
+declare class YuwAlertComponent {
+    readonly variant: _angular_core.InputSignal<YuwAlertVariantDto>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly userClass: _angular_core.InputSignal<string>;
+    protected readonly hasAction: _angular_core.Signal<YuwAlertActionDirective | undefined>;
+    protected readonly titleSlot: _angular_core.Signal<YuwAlertTitleDirective | undefined>;
+    protected readonly descriptionSlot: _angular_core.Signal<YuwAlertDescriptionDirective | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwAlertComponent, "yuw-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["hasAction", "titleSlot", "descriptionSlot"], ["[yuwAlertIcon]", "[yuwAlertTitle]", "[yuwAlertDescription]", "*", "[yuwAlertAction]"], true, never>;
+}
+declare const YuwAlertImports: readonly [typeof YuwAlertComponent, typeof YuwAlertActionDirective, typeof YuwAlertTitleDirective, typeof YuwAlertDescriptionDirective];
+
+/**
+ * Marks an element as the dialog's footer content, projected into the footer slot.
+ * Its presence is also what makes the footer render at all — without it the dialog
+ * shows no empty footer strip.
+ */
+declare class YuwDialogFooterDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwDialogFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwDialogFooterDirective, "[yuwDialogFooter]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Modal dialog overlay for focused tasks and forms.
+ *
+ * Accessibility: provide either `title` or `ariaLabel` — a modal without an accessible name is
+ * announced as an anonymous dialog by screen readers.
+ *
+ * Inputs / Models:
+ * - `open`: Two-way open/closed state. Drive via `[(open)]` to control it programmatically.
+ * - `showTrigger`: Whether to render the trigger button. Set `false` when opening only via `[(open)]`.
+ * - `title`: Header title text. User-facing text the consuming app is responsible for translating.
+ * - `description`: Header description text. User-facing text the consuming app is responsible for translating.
+ * - `ariaLabel`: Accessible name for the dialog when no visible `title` is rendered. User-facing
+ *   text the consuming app is responsible for translating.
+ * - `closeLabel`: Accessible label of the corner close (×) button. When set, the close button
+ *   renders and screen readers read this label; when absent there is no close button. User-facing
+ *   text the consuming app is responsible for translating.
+ * - `panelClass`: Extra classes merged onto the dialog panel (e.g. `sm:max-w-lg` to widen it).
+ *   They win over the library defaults via `twMerge`.
+ * - `triggerVariant`: Button style variant for the trigger button. Default is `'outline'`.
+ * - `triggerSize`: Button size for the trigger button.
+ *
+ * Content slots:
+ * - `[yuwDialogTrigger]`: Trigger button content.
+ * - `[yuwDialogFooter]`: Footer actions (`YuwDialogFooterDirective`). The footer only renders when
+ *   this slot is filled.
+ *
+ * The projected body scrolls internally when it is taller than the viewport, like `<yuw-sheet>`.
+ *
+ * Usage:
+ * ```html
+ * <yuw-dialog [(open)]="isOpen" title="Crear proyecto" description="Asigna un nombre para empezar." closeLabel="Cerrar">
+ *   <ng-container yuwDialogTrigger>Crear proyecto</ng-container>
+ *
+ *   <yuw-input [(value)]="name" label="Nombre" />
+ *
+ *   <div yuwDialogFooter>
+ *     <yuw-button (clicked)="save()">Guardar</yuw-button>
+ *   </div>
+ * </yuw-dialog>
+ * ```
+ */
+declare class YuwDialogComponent {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly showTrigger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly closeLabel: _angular_core.InputSignal<string | undefined>;
+    readonly panelClass: _angular_core.InputSignal<string | undefined>;
+    readonly triggerVariant: _angular_core.InputSignal<"secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined>;
+    readonly triggerSize: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    protected readonly hasFooter: _angular_core.Signal<YuwDialogFooterDirective | undefined>;
+    protected readonly _dialogState: _angular_core.Signal<"open" | "closed">;
+    protected onStateChanged(state: 'open' | 'closed'): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwDialogComponent, "yuw-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "showTrigger": { "alias": "showTrigger"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "triggerVariant": { "alias": "triggerVariant"; "required": false; "isSignal": true; }; "triggerSize": { "alias": "triggerSize"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, ["hasFooter"], ["[yuwDialogTrigger]", "*", "[yuwDialogFooter]"], true, never>;
+}
+declare const YuwDialogImports: readonly [typeof YuwDialogComponent, typeof YuwDialogFooterDirective];
+
+/**
+ * Marks a projected element as the leading media of a `<yuw-alert-dialog>`, rendered in a
+ * highlighted square above or beside the title.
+ */
+declare class YuwAlertDialogMediaDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAlertDialogMediaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAlertDialogMediaDirective, "[yuwAlertDialogMedia]", never, {}, {}, never, never, true, never>;
+}
+
+type YuwAlertDialogSizeDto = 'sm' | 'default';
+/**
+ * Blocking confirmation dialog for destructive or irreversible actions. Unlike `<yuw-dialog>` it
+ * cannot be dismissed by clicking the backdrop, so the user must pick one of the two actions.
+ *
+ * Inputs / Models:
+ * - `open`: Two-way open/closed state. Drive via `[(open)]` to control it programmatically.
+ * - `showTrigger`: Whether to render the trigger button. Set `false` when opening only via `[(open)]`.
+ * - `title`: Header title text. User-facing text the consuming app is responsible for translating.
+ * - `description`: Header description text. User-facing text the consuming app is responsible for translating.
+ * - `confirmLabel`: Label of the confirm action. User-facing text the consuming app is responsible for translating.
+ * - `cancelLabel`: Label of the cancel action. User-facing text the consuming app is responsible for translating.
+ * - `confirmVariant`: Button style variant for the confirm action. Use `'destructive'` for deletions.
+ * - `size`: Content width (`'sm'`, `'default'`). Default is `'default'`.
+ * - `triggerVariant`: Button style variant for the trigger button.
+ * - `triggerSize`: Button size for the trigger button.
+ *
+ * Outputs:
+ * - `confirmed`: Emitted when the confirm action is activated.
+ * - `cancelled`: Emitted only when the cancel button is activated — programmatic closes (setting
+ *   `open` to `false`) do not emit it.
+ *
+ * Content slots:
+ * - `[yuwAlertDialogTrigger]`: Trigger button content.
+ * - `[yuwAlertDialogMedia]`: Leading media/icon shown above or beside the title.
+ *
+ * Usage:
+ * ```html
+ * <yuw-alert-dialog
+ *   [(open)]="isOpen"
+ *   title="¿Eliminar factura?"
+ *   description="Esta acción no se puede deshacer."
+ *   confirmLabel="Eliminar"
+ *   cancelLabel="Cancelar"
+ *   confirmVariant="destructive"
+ *   (confirmed)="delete()" />
+ * ```
+ */
+declare class YuwAlertDialogComponent {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly showTrigger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly confirmLabel: _angular_core.InputSignal<string>;
+    readonly cancelLabel: _angular_core.InputSignal<string>;
+    readonly confirmVariant: _angular_core.InputSignal<"secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined>;
+    readonly size: _angular_core.InputSignal<YuwAlertDialogSizeDto>;
+    readonly triggerVariant: _angular_core.InputSignal<"secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined>;
+    readonly triggerSize: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    readonly confirmed: _angular_core.OutputEmitterRef<void>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    protected readonly hasMedia: _angular_core.Signal<YuwAlertDialogMediaDirective | undefined>;
+    protected readonly _dialogState: _angular_core.Signal<"open" | "closed">;
+    protected onStateChanged(state: 'open' | 'closed'): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAlertDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwAlertDialogComponent, "yuw-alert-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "showTrigger": { "alias": "showTrigger"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "confirmLabel": { "alias": "confirmLabel"; "required": true; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": true; "isSignal": true; }; "confirmVariant": { "alias": "confirmVariant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "triggerVariant": { "alias": "triggerVariant"; "required": false; "isSignal": true; }; "triggerSize": { "alias": "triggerSize"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "confirmed": "confirmed"; "cancelled": "cancelled"; }, ["hasMedia"], ["[yuwAlertDialogTrigger]", "[yuwAlertDialogMedia]", "*"], true, never>;
+}
+
+/** A single tab in `<yuw-tabs>`, pairing the trigger label with the id used to match its content. */
+interface YuwTabItemDto {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+
+/**
+ * Declares the content of a single `<yuw-tabs>` panel. Apply it to an `<ng-template>` and pass the
+ * id of the tab it belongs to, matching an entry in the `tabs` input.
+ *
+ * Usage:
+ * ```html
+ * <ng-template yuwTabPanel="billing">Contenido de facturación</ng-template>
+ * ```
+ */
+declare class YuwTabPanelDirective {
+    readonly tabId: _angular_core.InputSignal<string>;
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTabPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwTabPanelDirective, "ng-template[yuwTabPanel]", never, { "tabId": { "alias": "yuwTabPanel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type YuwTabsVariantDto = 'default' | 'line';
+type YuwTabsOrientationDto = 'horizontal' | 'vertical';
+type YuwTabsActivationModeDto = 'automatic' | 'manual';
+/**
+ * Tabbed navigation between sibling panels.
+ *
+ * Triggers come from the `tabs` input; each panel's content is declared by the consumer as an
+ * `<ng-template yuwTabPanel="<id>">` whose id matches a tab. Panels are lazy: a panel's content
+ * is only instantiated the first time its tab becomes active (and stays alive, hidden, after
+ * switching away).
+ *
+ * Inputs / Models:
+ * - `tabs`: The tab definitions (`YuwTabItemDto[]`) rendered as triggers, in order.
+ * - `activeTab`: Two-way id of the selected tab. Drive via `[(activeTab)]` to control it
+ *   programmatically; listen to `activeTabChange` to react to activations.
+ * - `variant`: Trigger list style (`'default'` filled, `'line'` underlined). Default is `'default'`.
+ * - `orientation`: Layout direction (`'horizontal'`, `'vertical'`). Default is `'horizontal'`.
+ * - `activationMode`: How keyboard focus activates tabs (`'automatic'` activates on focus,
+ *   `'manual'` requires Enter/Space). Default is `'automatic'`.
+ *
+ * Usage:
+ * ```html
+ * <yuw-tabs [tabs]="tabs" [(activeTab)]="selected">
+ *   <ng-template yuwTabPanel="general">Contenido general</ng-template>
+ *   <ng-template yuwTabPanel="billing">Contenido de facturación</ng-template>
+ * </yuw-tabs>
+ * ```
+ */
+declare class YuwTabsComponent {
+    readonly tabs: _angular_core.InputSignal<YuwTabItemDto[]>;
+    readonly activeTab: _angular_core.ModelSignal<string>;
+    readonly variant: _angular_core.InputSignal<YuwTabsVariantDto>;
+    readonly orientation: _angular_core.InputSignal<YuwTabsOrientationDto>;
+    readonly activationMode: _angular_core.InputSignal<YuwTabsActivationModeDto>;
+    protected readonly panels: _angular_core.Signal<readonly YuwTabPanelDirective[]>;
+    protected onTabActivated(tabId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwTabsComponent, "yuw-tabs", never, { "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "activeTab": { "alias": "activeTab"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; }, { "activeTab": "activeTabChange"; }, ["panels"], never, true, never>;
+}
+
+/**
+ * Container directive for a single file attachment card.
+ *
+ * Accepts `state` (`'idle'`, `'uploading'`, `'processing'`, `'error'`, `'done'`), `size`
+ * (`'default'`, `'sm'`, `'xs'`) and `orientation` (`'horizontal'`, `'vertical'`), which drive the
+ * styling of every nested slot.
+ *
+ * Usage:
+ * ```html
+ * <div yuwAttachment state="uploading">
+ *   <div yuwAttachmentMedia><ng-icon name="lucideFileText" /></div>
+ *   <div yuwAttachmentContent>
+ *     <span yuwAttachmentTitle>informe.pdf</span>
+ *     <span yuwAttachmentDescription>2,4 MB</span>
+ *   </div>
+ *   <div yuwAttachmentActions>
+ *     <button yuwAttachmentAction><ng-icon name="lucideX" /></button>
+ *   </div>
+ * </div>
+ * ```
+ */
+declare class YuwAttachmentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentDirective, "[yuwAttachment], yuw-attachment", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachment; inputs: { "state": "state"; "size": "size"; "orientation": "orientation"; }; outputs: {}; }]>;
+}
+/** Scrollable, snapping row that lays out several attachment cards. */
+declare class YuwAttachmentGroupDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentGroupDirective, "[yuwAttachmentGroup], yuw-attachment-group", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachmentGroup; inputs: {}; outputs: {}; }]>;
+}
+/** Leading media slot of an attachment, for a file-type icon or an image preview. Supports `variant` (`'icon'`, `'image'`). */
+declare class YuwAttachmentMediaDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentMediaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentMediaDirective, "[yuwAttachmentMedia], yuw-attachment-media", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachmentMedia; inputs: { "variant": "variant"; }; outputs: {}; }]>;
+}
+/** Text content container of an attachment, holding its title and description. */
+declare class YuwAttachmentContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentContentDirective, "[yuwAttachmentContent], yuw-attachment-content", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachmentContent; inputs: {}; outputs: {}; }]>;
+}
+/** File name of an attachment. Truncates and shimmers while the attachment is uploading or processing. */
+declare class YuwAttachmentTitleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentTitleDirective, "[yuwAttachmentTitle], yuw-attachment-title", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachmentTitle; inputs: {}; outputs: {}; }]>;
+}
+/** Secondary line of an attachment, for file size, progress, or an error message. */
+declare class YuwAttachmentDescriptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentDescriptionDirective, "[yuwAttachmentDescription], yuw-attachment-description", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachmentDescription; inputs: {}; outputs: {}; }]>;
+}
+/** Trailing container for an attachment's action buttons. */
+declare class YuwAttachmentActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentActionsDirective, "[yuwAttachmentActions], yuw-attachment-actions", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachmentActions; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Icon-sized action button inside an attachment, such as remove or retry.
+ *
+ * Besides `type`, accepts the button `variant` and `size` (defaults `'ghost'` / `'icon-xs'`).
+ * Extends `HlmAttachmentAction` (instead of composing it via `hostDirectives`) because
+ * `variant`/`size` are inputs the helm only exposes from its own `HlmButton` host directive, and
+ * host-directive forwarding is not transitive (NG2017) — inheritance carries the whole surface
+ * over as real `HlmButton` inputs, so the cva variants resolve natively instead of being layered
+ * on top of the defaults. Angular does not inherit `providers`, so the helm's
+ * `provideBrnButtonConfig` defaults are mirrored here; keep them in sync with
+ * `helm/attachment/src/lib/hlm-attachment-action.ts` if the helm is regenerated.
+ */
+declare class YuwAttachmentActionDirective extends HlmAttachmentAction {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentActionDirective, "button[yuwAttachmentAction]", never, {}, {}, never, never, true, never>;
+}
+/** Turns the whole attachment card into a single clickable target, layered under its actions. */
+declare class YuwAttachmentTriggerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwAttachmentTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwAttachmentTriggerDirective, "button[yuwAttachmentTrigger], a[yuwAttachmentTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1$8.HlmAttachmentTrigger; inputs: { "type": "type"; }; outputs: {}; }]>;
+}
+
+type YuwSidebarSideDto = 'left' | 'right';
+type YuwSidebarVariantDto = 'sidebar' | 'floating' | 'inset';
+type YuwSidebarCollapsibleDto = 'offcanvas' | 'icon' | 'none';
+/**
+ * Collapsible navigation sidebar. Renders as a fixed panel on desktop and as a slide-in sheet on
+ * mobile, and reads its colors from the `--sidebar-*` theme tokens.
+ *
+ * Place it inside a `[yuwSidebarWrapper]` alongside a `<main yuwSidebarInset>`, and compose its
+ * inner structure with the `yuwSidebar*` directives. Open state is shared through
+ * `YuwSidebarService`, so `<yuw-sidebar-trigger>` works from anywhere in the page.
+ *
+ * Inputs:
+ * - `side`: Edge the sidebar is docked to (`'left'`, `'right'`). Default is `'left'`.
+ * - `variant`: Panel treatment (`'sidebar'` flush, `'floating'` card, `'inset'` inset page). Default is `'sidebar'`.
+ * - `collapsible`: Collapse behaviour (`'offcanvas'` slides away, `'icon'` shrinks to icons, `'none'` always open). Default is `'offcanvas'`.
+ * - `sidebarWidthMobile`: Width of the mobile slide-in sheet (any CSS length). Defaults to the helm sidebar config (`18rem`).
+ * - `sidebarContainerClass`: Extra classes merged onto the desktop fixed container (the helm merges them last, so they win).
+ *
+ * Deliberately not exposed from the helm sidebar (add a wrapper only when a real consumer needs
+ * them): `HlmSidebarMenuAction`, `HlmSidebarMenuSkeleton`, `HlmSidebarInput` and
+ * `HlmSidebarGroupAction`.
+ *
+ * Usage:
+ * ```html
+ * <yuw-sidebar collapsible="icon">
+ *   <div yuwSidebarHeader>Yurest</div>
+ *   <div yuwSidebarContent>
+ *     <ul yuwSidebarMenu>
+ *       <li yuwSidebarMenuItem><a yuwSidebarMenuButton isActive tooltip="Pedidos">Pedidos</a></li>
+ *     </ul>
+ *   </div>
+ * </yuw-sidebar>
+ * ```
+ */
+declare class YuwSidebarComponent {
+    private readonly config;
+    readonly side: _angular_core.InputSignal<YuwSidebarSideDto>;
+    readonly variant: _angular_core.InputSignal<YuwSidebarVariantDto>;
+    readonly collapsible: _angular_core.InputSignal<YuwSidebarCollapsibleDto>;
+    readonly sidebarWidthMobile: _angular_core.InputSignal<string>;
+    readonly sidebarContainerClass: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwSidebarComponent, "yuw-sidebar", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "sidebarWidthMobile": { "alias": "sidebarWidthMobile"; "required": false; "isSignal": true; }; "sidebarContainerClass": { "alias": "sidebarContainerClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Icon button that toggles the sidebar open or collapsed. Works anywhere on the page, including
+ * inside `<main yuwSidebarInset>`, since the open state lives in `YuwSidebarService`.
+ *
+ * Inputs:
+ * - `label`: Screen-reader-only label for the button. User-facing text the consuming app is
+ *   responsible for translating.
+ *
+ * Usage:
+ * ```html
+ * <yuw-sidebar-trigger label="Alternar menú" />
+ * ```
+ */
+declare class YuwSidebarTriggerComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarTriggerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuwSidebarTriggerComponent, "yuw-sidebar-trigger", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Outermost layout directive for a sidebar page. Wraps the sidebar and the main content, and owns
+ * the `--sidebar-width` / `--sidebar-width-icon` custom properties via its `sidebarWidth` and
+ * `sidebarWidthIcon` inputs.
+ *
+ * Usage:
+ * ```html
+ * <div yuwSidebarWrapper>
+ *   <yuw-sidebar collapsible="icon">
+ *     <div yuwSidebarHeader>Yurest</div>
+ *     <div yuwSidebarContent>
+ *       <div yuwSidebarGroup>
+ *         <div yuwSidebarGroupLabel>Gestión</div>
+ *         <div yuwSidebarGroupContent>
+ *           <ul yuwSidebarMenu>
+ *             <li yuwSidebarMenuItem>
+ *               <a yuwSidebarMenuButton isActive tooltip="Pedidos">Pedidos</a>
+ *             </li>
+ *           </ul>
+ *         </div>
+ *       </div>
+ *     </div>
+ *   </yuw-sidebar>
+ *
+ *   <main yuwSidebarInset>
+ *     <button yuw-sidebar-trigger></button>
+ *   </main>
+ * </div>
+ * ```
+ */
+declare class YuwSidebarWrapperDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarWrapperDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarWrapperDirective, "[yuwSidebarWrapper], yuw-sidebar-wrapper", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarWrapper; inputs: { "sidebarWidth": "sidebarWidth"; "sidebarWidthIcon": "sidebarWidthIcon"; }; outputs: {}; }]>;
+}
+/** Top area of the sidebar, above the scrollable content. */
+declare class YuwSidebarHeaderDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarHeaderDirective, "[yuwSidebarHeader], yuw-sidebar-header", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarHeader; inputs: {}; outputs: {}; }]>;
+}
+/** Scrollable middle area of the sidebar that holds the navigation groups. */
+declare class YuwSidebarContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarContentDirective, "[yuwSidebarContent], yuw-sidebar-content", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarContent; inputs: {}; outputs: {}; }]>;
+}
+/** Bottom area of the sidebar, below the scrollable content. */
+declare class YuwSidebarFooterDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarFooterDirective, "[yuwSidebarFooter], yuw-sidebar-footer", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarFooter; inputs: {}; outputs: {}; }]>;
+}
+/** A titled section of the sidebar. */
+declare class YuwSidebarGroupDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarGroupDirective, "[yuwSidebarGroup], yuw-sidebar-group", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarGroup; inputs: {}; outputs: {}; }]>;
+}
+/** Heading of a sidebar group. Fades out when the sidebar collapses to icons. */
+declare class YuwSidebarGroupLabelDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarGroupLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarGroupLabelDirective, "div[yuwSidebarGroupLabel], button[yuwSidebarGroupLabel]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarGroupLabel; inputs: {}; outputs: {}; }]>;
+}
+/** Body of a sidebar group, wrapping its menu. */
+declare class YuwSidebarGroupContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarGroupContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarGroupContentDirective, "div[yuwSidebarGroupContent]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarGroupContent; inputs: {}; outputs: {}; }]>;
+}
+/** Navigation list of a sidebar group. Apply to a `<ul>`. */
+declare class YuwSidebarMenuDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarMenuDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarMenuDirective, "ul[yuwSidebarMenu]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarMenu; inputs: {}; outputs: {}; }]>;
+}
+/** A single entry of a sidebar menu. Apply to an `<li>`. */
+declare class YuwSidebarMenuItemDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarMenuItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarMenuItemDirective, "li[yuwSidebarMenuItem]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarMenuItem; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Interactive control of a sidebar menu item. Accepts `variant` (`'default'`, `'outline'`), `size`
+ * (`'default'`, `'sm'`, `'lg'`) and `isActive`.
+ *
+ * To label the item while the sidebar is collapsed to icons, add Spartan's `tooltip` input
+ * alongside this directive — it comes from the underlying menu-button primitive and is only shown
+ * in the collapsed state.
+ */
+declare class YuwSidebarMenuButtonDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarMenuButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarMenuButtonDirective, "button[yuwSidebarMenuButton], a[yuwSidebarMenuButton]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarMenuButton; inputs: { "variant": "variant"; "size": "size"; "isActive": "isActive"; "closeMobileSidebarOnClick": "closeMobileSidebarOnClick"; }; outputs: {}; }]>;
+}
+/** Trailing count or status badge of a sidebar menu item. */
+declare class YuwSidebarMenuBadgeDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarMenuBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarMenuBadgeDirective, "[yuwSidebarMenuBadge], yuw-sidebar-menu-badge", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarMenuBadge; inputs: {}; outputs: {}; }]>;
+}
+/** Nested submenu list of a sidebar menu item. Apply to a `<ul>`. */
+declare class YuwSidebarMenuSubDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarMenuSubDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarMenuSubDirective, "ul[yuwSidebarMenuSub]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarMenuSub; inputs: {}; outputs: {}; }]>;
+}
+/** A single entry of a sidebar submenu. Apply to an `<li>`. */
+declare class YuwSidebarMenuSubItemDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarMenuSubItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarMenuSubItemDirective, "li[yuwSidebarMenuSubItem]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarMenuSubItem; inputs: {}; outputs: {}; }]>;
+}
+/** Interactive control of a sidebar submenu item. Accepts `size` (`'sm'`, `'md'`) and `isActive`. */
+declare class YuwSidebarMenuSubButtonDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarMenuSubButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarMenuSubButtonDirective, "a[yuwSidebarMenuSubButton], button[yuwSidebarMenuSubButton]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarMenuSubButton; inputs: { "size": "size"; "isActive": "isActive"; "closeMobileSidebarOnClick": "closeMobileSidebarOnClick"; }; outputs: {}; }]>;
+}
+/** Divider between sidebar sections. */
+declare class YuwSidebarSeparatorDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarSeparatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarSeparatorDirective, "[yuwSidebarSeparator], yuw-sidebar-separator", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarSeparator; inputs: {}; outputs: {}; }]>;
+}
+/** Thin draggable edge that toggles the sidebar. Apply to a `<button>`. */
+declare class YuwSidebarRailDirective {
+    /**
+     * Accessible label of the rail button (it has no visible text). User-facing text — the
+     * consuming app is responsible for providing it already translated.
+     */
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarRailDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarRailDirective, "button[yuwSidebarRail]", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarRail; inputs: {}; outputs: {}; }]>;
+}
+/** Main content region beside the sidebar. Apply to a `<main>`. */
+declare class YuwSidebarInsetDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuwSidebarInsetDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<YuwSidebarInsetDirective, "main[yuwSidebarInset]", never, {}, {}, never, never, true, [{ directive: typeof i1$9.HlmSidebarInset; inputs: {}; outputs: {}; }]>;
+}
+
+export { YUW_DATATABLE_FEATURES, YUW_PASSWORD_REVEAL_STATES, YuwAccordion, YuwAccordionContentComponent, YuwAccordionImports, YuwAccordionItem, YuwAccordionTriggerComponent, YuwAlertActionDirective, YuwAlertComponent, YuwAlertDescriptionDirective, YuwAlertDialogComponent, YuwAlertDialogMediaDirective, YuwAlertImports, YuwAlertTitleDirective, YuwAttachmentActionDirective, YuwAttachmentActionsDirective, YuwAttachmentContentDirective, YuwAttachmentDescriptionDirective, YuwAttachmentDirective, YuwAttachmentGroupDirective, YuwAttachmentMediaDirective, YuwAttachmentTitleDirective, YuwAttachmentTriggerDirective, YuwAvatarComponent, YuwBadgeComponent, YuwBreadcrumbComponent, YuwButtonComponent, YuwCaptionDirective, YuwCardActionDirective, YuwCardContentDirective, YuwCardDescriptionDirective, YuwCardDirective, YuwCardFooterDirective, YuwCardHeaderDirective, YuwCardImports, YuwCardTitleDirective, YuwCheckboxComponent, YuwComboboxComponent, YuwComboboxItemDirective, YuwContextMenuCheckboxDirective, YuwContextMenuCheckboxIndicatorComponent, YuwContextMenuDirective, YuwContextMenuGroupDirective, YuwContextMenuImports, YuwContextMenuItemDirective, YuwContextMenuLabelDirective, YuwContextMenuRadioDirective, YuwContextMenuRadioIndicatorComponent, YuwContextMenuSeparatorDirective, YuwContextMenuShortcutDirective, YuwContextMenuSubDirective, YuwContextMenuSubIndicatorComponent, YuwContextMenuSubTriggerDirective, YuwContextMenuTriggerDirective, YuwDatatableComponent, YuwDatepickerComponent, YuwDialogComponent, YuwDialogFooterDirective, YuwDialogImports, YuwEmptyContentDirective, YuwEmptyDescriptionDirective, YuwEmptyDirective, YuwEmptyHeaderDirective, YuwEmptyImports, YuwEmptyMediaDirective, YuwEmptyTitleDirective, YuwInputAddonImports, YuwInputComponent, YuwInputOtpComponent, YuwItemActionsDirective, YuwItemContentDirective, YuwItemDescriptionDirective, YuwItemDirective, YuwItemFooterDirective, YuwItemGroupDirective, YuwItemHeaderDirective, YuwItemImports, YuwItemMediaDirective, YuwItemSeparatorDirective, YuwItemTitleDirective, YuwLabel, YuwLeftAddonDirective, YuwPaginationComponent, YuwPasswordInputComponent, YuwPopoverComponent, YuwRadioGroupComponent, YuwRightAddonDirective, YuwSearchInputComponent, YuwSheetComponent, YuwSheetFooterDirective, YuwSheetImports, YuwSidebarComponent, YuwSidebarContentDirective, YuwSidebarFooterDirective, YuwSidebarGroupContentDirective, YuwSidebarGroupDirective, YuwSidebarGroupLabelDirective, YuwSidebarHeaderDirective, YuwSidebarInsetDirective, YuwSidebarMenuBadgeDirective, YuwSidebarMenuButtonDirective, YuwSidebarMenuDirective, YuwSidebarMenuItemDirective, YuwSidebarMenuSubButtonDirective, YuwSidebarMenuSubDirective, YuwSidebarMenuSubItemDirective, YuwSidebarRailDirective, YuwSidebarSeparatorDirective, YuwSidebarTriggerComponent, YuwSidebarWrapperDirective, YuwSkeletonDirective, YuwSpinnerComponent, YuwSwitchComponent, YuwTBodyDirective, YuwTFootDirective, YuwTHeadDirective, YuwTabPanelDirective, YuwTableContainerDirective, YuwTableDirective, YuwTableImports, YuwTabsComponent, YuwTdDirective, YuwTextareaComponent, YuwThDirective, YuwToasterComponent, YuwTooltipDirective, YuwTrDirective, YuwValueAccessorBase, buildInputOtpGroups, cn, getPaginationRange, provideValueAccessor, totalInputOtpLength };
+export type { YuwAlertDialogSizeDto, YuwAlertVariantDto, YuwAvatarGroupItemDto, YuwAvatarSizeDto, YuwBreadcrumbItemDto, YuwButtonGroupClickDto, YuwButtonGroupItemDto, YuwColorDto, YuwComboboxItemContext, YuwComboboxOptionDto, YuwComboboxValue, YuwDatatableColumnDef, YuwDatatableFeatures, YuwDatepickerModeDto, YuwDatepickerValue, YuwInputModeDto, YuwInputOtpGroupDto, YuwInputOtpModeDto, YuwInputTypeDto, YuwPaginationRangeItem, YuwPaginationSizeDto, YuwPasswordRevealStateDto, YuwPopoverAlignDto, YuwRadioOptionDto, YuwSheetSideDto, YuwSidebarCollapsibleDto, YuwSidebarSideDto, YuwSidebarVariantDto, YuwSwitchSizeDto, YuwTabItemDto, YuwTabsActivationModeDto, YuwTabsOrientationDto, YuwTabsVariantDto, YuwTextFieldContract, YuwToasterPositionDto, YuwToasterThemeDto, YuwTooltipPositionDto };