@uni-design-system/uni-angular 3.0.2 → 5.0.0

package/types/uni-design-system-uni-angular.d.ts

@@ -1,8 +1,78 @@
 import * as _angular_core from '@angular/core';
-import { Signal, WritableSignal, InjectionToken, ElementRef, EventEmitter, OnInit, OnDestroy, OnChanges, SimpleChanges, TemplateRef, AfterViewInit } from '@angular/core';
+import { Signal, WritableSignal, InjectionToken, ElementRef, TemplateRef, OnInit, OnDestroy, AfterViewInit } from '@angular/core';
 import * as _uni_design_system_uni_core from '@uni-design-system/uni-core';
-import { Icons, Variant, ContainerColorToken, UniTheme, ComponentName, ComponentTheme, NullableSize, ThemeName, TextRole, ContentColorToken, Size, Thickness, NullableStyleExpression, ColorKey, Typeface, Radius, OptionalSize, Border, Shadow, ZIndexableElements, ColorToken, RadiiSize, Elevation, JustifyContent, StyleExpression, Orientation, OptionalAlignSelf, OptionalAlignItems, OptionalAlignContent, OptionalJustifyContent, OptionalDisplay, OptionalPosition, OptionalOverflow, OptionalFlexDirection, OptionalTextAlign, OptionalWrap } from '@uni-design-system/uni-core';
-import { Placement as Placement$1, OffsetOptions } from '@floating-ui/dom';
+import { Icons, Variant, ContainerColorToken, PaletteConfig, GenerateColorsConfig, UniTheme, ComponentName, ComponentTheme, NullableSize, ThemeName, TextRole, ContentColorToken, Size, Thickness, NullableStyleExpression, ColorKey, ColorToken, Typeface, Radius, OptionalSize, Border, Shadow, ZIndexableElements, RadiiSize, Elevation, TextColor, JustifyContent, StyleExpression, Orientation, OptionalAlignSelf, OptionalAlignItems, OptionalAlignContent, OptionalJustifyContent, OptionalDisplay, OptionalPosition, OptionalOverflow, OptionalFlexDirection, OptionalTextAlign, OptionalWrap, ColorScheme, ColorCategory } from '@uni-design-system/uni-core';
+import { FormCheckboxControl, FormValueControl } from '@angular/forms/signals';
+
+/**
+ * Returns a document-unique id for wiring ARIA relationships
+ * (aria-controls, aria-describedby, aria-labelledby, ...).
+ */
+declare function uniqueId(prefix?: string): string;
+/**
+ * Selector matching natively focusable elements. Used to locate the
+ * interactive element inside a projected trigger so ARIA attributes land
+ * on the element that actually receives focus.
+ */
+declare const FOCUSABLE_SELECTOR = "button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])";
+/**
+ * Resolves the element that should carry ARIA state for a trigger:
+ * the element itself when focusable, otherwise its first focusable descendant.
+ */
+declare function resolveFocusTarget(element: HTMLElement): HTMLElement;
+/**
+ * Visually hides content while keeping it available to screen readers.
+ * Use for text alternatives (e.g. badge counts, icon-only affordances).
+ */
+declare const visuallyHidden: {
+    readonly position: "absolute";
+    readonly width: 1;
+    readonly height: 1;
+    readonly padding: 0;
+    readonly margin: -1;
+    readonly overflow: "hidden";
+    readonly clipPath: "inset(50%)";
+    readonly whiteSpace: "nowrap";
+    readonly border: 0;
+};
+/**
+ * Wraps animation/transition styles so they only apply when the user has
+ * not requested reduced motion (WCAG 2.3.3).
+ */
+declare function motionSafe<T extends object>(styles: T): {
+    '@media (prefers-reduced-motion: no-preference)': T;
+};
+
+/**
+ * Native CSS Anchor Positioning helpers (Baseline 2026). These replace the
+ * former @floating-ui/dom dependency: the browser tracks the anchor natively
+ * (no scroll/resize listeners), and `position-try-fallbacks` flips the panel
+ * at viewport edges where supported (Chrome 125+, Firefox 147+, Safari 26+;
+ * older Baseline browsers still position correctly but do not auto-flip).
+ */
+type Placement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'right-start' | 'bottom-start' | 'left-start' | 'top-end' | 'right-end' | 'bottom-end' | 'left-end';
+/** Distances between the anchor and the positioned panel, in px. */
+interface AnchorOffset {
+    /** Gap along the placement axis (anchor → panel). */
+    mainAxis?: number;
+    /** Shift along the cross axis, from the aligned edge. */
+    alignmentAxis?: number;
+}
+/** Returns a document-unique dashed-ident usable as a CSS `anchor-name`. */
+declare function newAnchorName(): string;
+/**
+ * Emotion style object anchoring a panel to `anchor` at `placement`.
+ * Spread into the panel's `css()` styles. The trigger element must carry
+ * `anchor-name: <anchor>` (see `newAnchorName`).
+ */
+declare function anchorStyles(anchor: string, placement: Placement, offset?: AnchorOffset): Record<string, string | number>;
+/**
+ * Absolute positioning for a rotated-square arrow sitting on the panel edge
+ * that faces the anchor. Static per placement: if the browser flips the panel
+ * via position-try, the arrow stays on the configured side (cosmetic-only
+ * degradation, matching the flip-support caveat above).
+ */
+declare function anchorArrowStyles(placement: Placement, size?: number): Record<string, string | number>;
 
 type SortDirection = 'asc' | 'desc' | 'indet';
 interface Sort<T> {
@@ -183,7 +253,22 @@ declare function useTimer(): {
     secondsRemaining: _angular_core.Signal<number>;
 };
 
+declare const acceptableFile: (file: File, acceptedFileExtensions: string[] | undefined) => boolean;
+declare const getFileExtension: (file: File) => string;
+
+/**
+ * The editable shape a theme builder manipulates: a seed + scheme + category
+ * (plus optional saturation floor, brand colors, and light/dark mode).
+ * Everything else in a theme is derived from this. Brand colors come in two
+ * strengths: `brand` pins are emitted verbatim (may fail contrast), `targets`
+ * are brand-faithful but the WCAG guard-rail may adjust their lightness.
+ */
+type BrandPaletteConfig = Required<Pick<PaletteConfig, 'seed' | 'scheme' | 'category'>> & Pick<GenerateColorsConfig, 'mode' | 'accentSaturationFloor' | 'brand' | 'targets'>;
 declare class ThemeService {
+    /** localStorage key marking the custom brand theme as active. */
+    static readonly CUSTOM_KEY = "CustomTheme";
+    /** localStorage key holding the serialized brand palette config. */
+    static readonly PALETTE_KEY = "uni-custom-palette";
     private themes;
     private localStorage;
     theme: _angular_core.WritableSignal<UniTheme>;
@@ -191,7 +276,7 @@ declare class ThemeService {
     components: Signal<Partial<Record<ComponentName, ComponentTheme<object>>>>;
     component: <T>(componentName: ComponentName) => Signal<ComponentTheme<T>>;
     colors: Signal<Partial<Record<string, string>>>;
-    typeFaces: Signal<Partial<Record<string, _uni_design_system_uni_core.TypeFaceDefinition>>>;
+    typeFaces: Signal<Record<string, _uni_design_system_uni_core.TypeFaceDefinition>>;
     spacing: Signal<Partial<Record<NullableSize, string | number>>>;
     thicknesses: Signal<_uni_design_system_uni_core.Thicknesses>;
     radii: Signal<Partial<Record<string, string>>>;
@@ -200,11 +285,22 @@ declare class ThemeService {
     icons: Signal<_uni_design_system_uni_core.Icons>;
     constructor();
     selectTheme(themeName: ThemeName): void;
+    /** The live brand palette config, when a custom theme is active. */
+    customPalette: _angular_core.WritableSignal<BrandPaletteConfig>;
+    isCustomTheme: Signal<boolean>;
+    /**
+     * Generate a full theme from a brand palette config and make it active. When
+     * `persist` is true the config is saved so every subsequent story (and
+     * reload) renders with the same brand.
+     */
+    applyPalette(config: BrandPaletteConfig, persist?: boolean): void;
+    /** Drop the custom brand theme and fall back to the first built-in theme. */
+    clearCustomPalette(): void;
     selectedThemeName: Signal<string>;
     selectedThemeKey: _angular_core.WritableSignal<string>;
     textClass: (textRole: TextRole, textColor?: ContentColorToken) => string;
     componentStyle: (componentName: ComponentName, variant: Variant, size: Size) => Signal<{
-        [x: string]: string | number;
+        [x: string]: string | number | _uni_design_system_uni_core.StyleExpression;
     }>;
     getSpacing: (size: NullableSize) => string | number;
     getThickness: (thickness: Thickness) => string | number;
@@ -213,6 +309,16 @@ declare class ThemeService {
     backgroundColor: (token?: ColorKey) => NullableStyleExpression;
     backgroundImage: (url?: string) => NullableStyleExpression;
     getContainerColors: (color: Variant, useVariant?: boolean) => _uni_design_system_uni_core.StyleExpression;
+    /**
+     * Shared keyboard-focus indicator (WCAG 2.4.7). Spread into a component's
+     * Emotion styles: `...this.theme.focusRing()` or `focusRing('primary')`.
+     */
+    focusRing: (token?: ColorToken) => {
+        '&:focus-visible': {
+            outline: string;
+            outlineOffset: string;
+        };
+    };
     typeface: (typeface?: Typeface) => _uni_design_system_uni_core.TypeFaceDefinition;
     colorPalette: () => Partial<Record<string, string>>;
     color(color?: ColorKey): NullableStyleExpression;
@@ -250,6 +356,19 @@ declare class ThemeService {
 
 declare const UNI_THEMES: InjectionToken<Record<string, UniTheme>>;
 
+type ImagePosition = 'top' | 'bottom' | 'left' | 'right' | 'center' | string;
+declare class UniBackgroundComponent {
+    theme: ThemeService;
+    image: _angular_core.InputSignal<string>;
+    imagePosition: _angular_core.InputSignal<string>;
+    imageSize: _angular_core.InputSignal<string | number>;
+    height: _angular_core.InputSignal<string | number>;
+    width: _angular_core.InputSignal<string | number>;
+    protected readonly className: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniBackgroundComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniBackgroundComponent, "uni-background, Background", never, { "image": { "alias": "image"; "required": false; "isSignal": true; }; "imagePosition": { "alias": "imagePosition"; "required": false; "isSignal": true; }; "imageSize": { "alias": "imageSize"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 declare class BaseComponent<T = unknown> {
     protected componentName: ComponentName;
     theme: ThemeService;
@@ -258,7 +377,7 @@ declare class BaseComponent<T = unknown> {
     componentTheme: _angular_core.Signal<_uni_design_system_uni_core.ComponentTheme<T>>;
     componentOptions: _angular_core.Signal<T>;
     style: _angular_core.Signal<{
-        [x: string]: string | number;
+        [x: string]: string | number | _uni_design_system_uni_core.StyleExpression;
     }>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseComponent<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseComponent<any>, "ng-component", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -271,10 +390,10 @@ interface UniBadgeOptions {
 declare class UniBadgeComponent extends BaseComponent<UniBadgeOptions> {
     color: _angular_core.InputSignal<Variant>;
     useVariant: _angular_core.InputSignal<boolean>;
-    width?: number;
-    get className(): string;
+    width: _angular_core.InputSignal<number>;
+    protected readonly className: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniBadgeComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniBadgeComponent, "div[uni-badge], Badge", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "useVariant": { "alias": "useVariant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniBadgeComponent, "div[uni-badge], Badge", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "useVariant": { "alias": "useVariant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class RippleDirective {
@@ -293,13 +412,33 @@ declare class UniButtonComponent extends BaseComponent {
     readonly disable: _angular_core.InputSignal<boolean>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly fullWidth: _angular_core.InputSignal<boolean>;
-    symbolLeft?: string;
-    symbolRight?: string;
+    readonly symbolLeft: _angular_core.InputSignal<string>;
+    readonly symbolRight: _angular_core.InputSignal<string>;
     spinnerBox: string;
-    get className(): string;
+    protected readonly className: _angular_core.Signal<string>;
     symbolSize: _angular_core.Signal<number>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniButtonComponent, "button[uni-text-button], Button, button[text-button]", never, { "disable": { "alias": "disable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "symbolLeft": { "alias": "symbolLeft"; "required": false; }; "symbolRight": { "alias": "symbolRight"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof RippleDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniButtonComponent, "button[uni-text-button], Button, button[text-button]", never, { "disable": { "alias": "disable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "symbolLeft": { "alias": "symbolLeft"; "required": false; "isSignal": true; }; "symbolRight": { "alias": "symbolRight"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof RippleDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class UniButtonGroupComponent {
+    private themeService;
+    protected readonly className: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniButtonGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniButtonGroupComponent, "uni-button-group, ButtonGroup", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface ButtonGroupConfig {
+    tooltipPlacement?: Placement;
+    buttonSize: Size;
+    buttons: ButtonGroupItem[];
+}
+interface ButtonGroupItem {
+    symbolName: string;
+    selected?: boolean;
+    tooltip?: string;
+    action?: (selectedState?: boolean) => boolean | void;
+    toggle?: WritableSignal<boolean>;
 }
 
 declare class UniCardContentComponent extends BaseComponent {
@@ -329,19 +468,145 @@ declare class UniCardComponent extends BaseComponent<UniCardOptions> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniCardComponent, "uni-card, Card", never, {}, {}, never, ["*"], true, never>;
 }
 
+interface UniCheckboxOptions {
+    size?: string | number;
+    borderRadius?: string | number;
+}
+
+declare class UniCheckboxComponent extends BaseComponent<UniCheckboxOptions> implements FormCheckboxControl {
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** Synced from required() validators by the Signal Forms [field] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /**
+     * Id(s) of external element(s) describing this control — typically your
+     * app-rendered error message — exposed as aria-describedby.
+     */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    /**
+     * Mixed state for "select all"-style parent checkboxes. Cleared
+     * automatically on the next user interaction, matching native behavior.
+     */
+    readonly indeterminate: _angular_core.ModelSignal<boolean>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    markAsTouched(): void;
+    handleChange(event: Event): void;
+    protected readonly checkboxLabel: _angular_core.Signal<string>;
+    protected readonly checkboxInput: _angular_core.Signal<string>;
+    getThemeColor(token: ColorToken): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniCheckboxComponent, "uni-checkbox, Checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; "indeterminate": "indeterminateChange"; }, never, never, true, never>;
+}
+
+interface UniDataSearchOptions {
+    border: Border;
+    borderRadius: Radius;
+    color: ContainerColorToken;
+    placeholderColor: TextColor;
+}
+
+declare class UniDataSearchComponent<T> extends BaseComponent<UniDataSearchOptions> {
+    datasource: _angular_core.InputSignal<UniDatasource<T>>;
+    placeholder: _angular_core.InputSignal<string>;
+    fields: _angular_core.InputSignal<string[]>;
+    searchValue: _angular_core.WritableSignal<string>;
+    inputClassName: string;
+    constructor();
+    onInput(event: Event): void;
+    filterData(value: string): void;
+    clearFilter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDataSearchComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDataSearchComponent<any>, "uni-data-search", never, { "datasource": { "alias": "datasource"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ColumnDefinition<T> {
+    columnDef: keyof T;
+    header: string;
+    cell?: (element: T) => string;
+    isSticky?: boolean;
+    template?: TemplateRef<T>;
+    textAlign?: 'left' | 'right' | 'center';
+}
+interface UniDataTableOptions {
+    border?: Border;
+    borderRadius?: Radius;
+    color?: ContainerColorToken;
+    elevation?: Elevation;
+    headerPadding?: NullableSize;
+    footerPadding?: NullableSize;
+    headerColor?: ContainerColorToken;
+    footerColor?: ContainerColorToken;
+    cellPadding?: NullableSize;
+    rowHoverColor?: ContainerColorToken;
+    thTextRole: TextRole;
+    thColor?: ContainerColorToken;
+    thPadding?: NullableSize;
+    thHorizontalBorder?: Border;
+    thVerticalBorder?: Border;
+    tdTextRole: TextRole;
+    tdColor?: ContainerColorToken;
+    tdStickyColor?: ContainerColorToken;
+    tdPadding?: NullableSize;
+    tdHorizontalBorder?: Border;
+    tdVerticalBorder?: Border;
+    loadingOverlayColor?: ColorKey;
+    loadingSpinnerColor?: ColorKey;
+    loadingSpinnerSize?: string | number;
+}
+
+declare class UniDataTableComponent<T> extends BaseComponent<UniDataTableOptions> {
+    datasource: _angular_core.InputSignal<UniDatasource<T>>;
+    columns: _angular_core.InputSignal<ColumnDefinition<T>[]>;
+    detailRowTemplate: _angular_core.InputSignal<TemplateRef<{
+        $implicit: T;
+        index: number;
+    }>>;
+    expandedIndex: _angular_core.WritableSignal<number>;
+    useMultiSelect: _angular_core.InputSignal<boolean>;
+    useRowClick: _angular_core.InputSignal<boolean>;
+    highlight?: _angular_core.InputSignal<(row: T) => boolean>;
+    height: _angular_core.InputSignal<string>;
+    scrollable: _angular_core.WritableSignal<boolean>;
+    loadingOverlayClass: string;
+    rowSelect: _angular_core.OutputEmitterRef<T>;
+    rowClick: _angular_core.OutputEmitterRef<T>;
+    protected readonly tableClass: _angular_core.Signal<string>;
+    protected readonly headerClass: _angular_core.Signal<string>;
+    protected readonly footerClass: _angular_core.Signal<string>;
+    protected readonly thClass: _angular_core.Signal<string>;
+    protected readonly tdClass: _angular_core.Signal<string>;
+    protected readonly trClass: _angular_core.Signal<string>;
+    protected readonly detailRowClass: _angular_core.Signal<string>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    toggleRow(index: number): void;
+    handleRowClick(row: T, index: number): void;
+    /** aria-sort value for a column header, or null when the column is unsorted. */
+    protected ariaSort(column: ColumnDefinition<T>): 'ascending' | 'descending' | null;
+    isHighlighted(row: T): boolean;
+    protected readonly String: StringConstructor;
+    handleScrollable(scrollable: boolean): void;
+    getBorder(name: string | undefined): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDataTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDataTableComponent<any>, "uni-data-table, DataTable", never, { "datasource": { "alias": "datasource"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "detailRowTemplate": { "alias": "detailRowTemplate"; "required": false; "isSignal": true; }; "useMultiSelect": { "alias": "useMultiSelect"; "required": false; "isSignal": true; }; "useRowClick": { "alias": "useRowClick"; "required": false; "isSignal": true; }; "highlight": { "alias": "highlight"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "rowSelect": "rowSelect"; "rowClick": "rowClick"; }, never, ["data-table-header", "data-table-footer"], true, never>;
+}
+
 declare class UniDialogButtonsComponent {
     private dialog;
-    confirmButtonText?: string;
-    confirmButtonVariant: Variant;
-    cancelButtonText?: string;
-    disableConfirm?: boolean;
-    padding?: NullableSize;
-    paddingBottom?: NullableSize;
-    justifyContent?: JustifyContent;
-    confirmed: EventEmitter<any>;
+    confirmButtonText: _angular_core.InputSignal<string>;
+    confirmButtonVariant: _angular_core.InputSignal<Variant>;
+    cancelButtonText: _angular_core.InputSignal<string>;
+    disableConfirm: _angular_core.InputSignal<boolean>;
+    padding: _angular_core.InputSignal<NullableSize>;
+    paddingBottom: _angular_core.InputSignal<NullableSize>;
+    justifyContent: _angular_core.InputSignal<JustifyContent>;
+    confirmed: _angular_core.OutputEmitterRef<void>;
     closeDialog(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDialogButtonsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDialogButtonsComponent, "uni-dialog-buttons, DialogButtons, div[dialog-buttons]", never, { "confirmButtonText": { "alias": "confirmButtonText"; "required": false; }; "confirmButtonVariant": { "alias": "confirmButtonVariant"; "required": false; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; "disableConfirm": { "alias": "disableConfirm"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "paddingBottom": { "alias": "paddingBottom"; "required": false; }; "justifyContent": { "alias": "justifyContent"; "required": false; }; }, { "confirmed": "confirmed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDialogButtonsComponent, "uni-dialog-buttons, DialogButtons, div[dialog-buttons]", never, { "confirmButtonText": { "alias": "confirmButtonText"; "required": false; "isSignal": true; }; "confirmButtonVariant": { "alias": "confirmButtonVariant"; "required": false; "isSignal": true; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; "isSignal": true; }; "disableConfirm": { "alias": "disableConfirm"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "paddingBottom": { "alias": "paddingBottom"; "required": false; "isSignal": true; }; "justifyContent": { "alias": "justifyContent"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; }, never, never, true, never>;
 }
 
 interface UniDialogHeaderOptions {
@@ -358,6 +623,9 @@ interface UniDialogHeaderOptions {
 
 declare class UniDialogHeaderComponent extends BaseComponent<UniDialogHeaderOptions> {
     private dialog;
+    /** Attached to the title element so the parent dialog is labelled by it. */
+    protected readonly titleId: string;
+    constructor();
     closeDialog(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDialogHeaderComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDialogHeaderComponent, "div[uni-dialog-header], DialogHeader", never, {}, {}, never, ["*"], true, never>;
@@ -374,29 +642,49 @@ interface UniDialogOptions {
 
 declare class UniDialogComponent extends BaseComponent<UniDialogOptions> {
     private elem;
-    show: _angular_core.InputSignal<boolean>;
-    private readonly _show;
-    defaultCloseButton?: boolean;
-    showing: EventEmitter<any>;
+    /** Two-way bindable open state: [(show)]. */
+    show: _angular_core.ModelSignal<boolean>;
+    /**
+     * Accessible name for dialogs without a DialogHeader. When a DialogHeader
+     * is present it labels the dialog automatically via aria-labelledby.
+     */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * CSS selector for the element to focus when the dialog opens. Defaults to
+     * the browser's native behavior (first focusable element).
+     */
+    initialFocus: _angular_core.InputSignal<string>;
+    defaultCloseButton: _angular_core.InputSignal<boolean>;
+    /** Id referenced by aria-labelledby; DialogHeader attaches it to the title. */
+    readonly titleId: string;
+    readonly hasTitle: _angular_core.WritableSignal<boolean>;
+    /** Emits true once opened and false once the closing animation finishes. */
+    showing: _angular_core.OutputEmitterRef<boolean>;
     constructor();
     private get _dialog();
-    get className(): string;
-    BackdropClick(event: Event): void;
-    ClosingAnimation(e: AnimationEvent): void;
+    protected readonly className: _angular_core.Signal<string>;
+    protected backdropClick(event: Event): void;
+    /**
+     * Escape fires the native 'cancel' event, which would close the dialog
+     * instantly and leave our show-state out of sync. Route it through the
+     * animated close() instead.
+     */
+    protected escapeCancel(event: Event): void;
+    protected closingAnimation(e: AnimationEvent): void;
     closeButton: string;
     private dialogFadeIn;
     private dialogFadeOut;
     open(): void;
     close(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDialogComponent, "dialog[uni-dialog], Dialog", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "defaultCloseButton": { "alias": "defaultCloseButton"; "required": false; }; }, { "showing": "showing"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDialogComponent, "dialog[uni-dialog], Dialog", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "defaultCloseButton": { "alias": "defaultCloseButton"; "required": false; "isSignal": true; }; }, { "show": "showChange"; "showing": "showing"; }, never, ["*"], true, never>;
 }
 
 declare class UniDividerComponent {
     themeService: ThemeService;
     orientation: _angular_core.InputSignal<Orientation>;
     border: _angular_core.InputSignal<string>;
-    get className(): string;
+    protected readonly className: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDividerComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDividerComponent, "uni-divider, Divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -408,14 +696,24 @@ interface UniDropdownOptions {
     color: ContainerColorToken;
 }
 
+type AriaHasPopup = 'menu' | 'listbox' | 'dialog' | 'grid' | 'tree' | 'true';
 declare class UniDropdownComponent extends BaseComponent<UniDropdownOptions> implements OnInit, OnDestroy {
     private renderer;
-    private cleanupAutoUpdate?;
     private delay;
     showing: _angular_core.WritableSignal<boolean>;
     trigger: _angular_core.InputSignal<HTMLElement>;
-    placement: _angular_core.InputSignal<Placement$1>;
-    offset: _angular_core.InputSignal<OffsetOptions>;
+    placement: _angular_core.InputSignal<Placement>;
+    offset: _angular_core.InputSignal<AnchorOffset>;
+    /** CSS anchor-name linking the trigger to the popover panel. */
+    private readonly anchorName;
+    /**
+     * Value for aria-haspopup on the trigger, describing what the popover
+     * contains (e.g. 'menu' for Menu, 'dialog' for rich content). When unset,
+     * only aria-expanded/aria-controls are managed.
+     */
+    ariaHasPopup: _angular_core.InputSignal<AriaHasPopup>;
+    /** Document-unique id of the popover element, for aria-controls wiring. */
+    readonly popoverId: string;
     paddingVertical: _angular_core.InputSignal<NullableSize>;
     paddingHorizontal: _angular_core.InputSignal<NullableSize>;
     dropdownShowing: _angular_core.OutputEmitterRef<boolean>;
@@ -425,39 +723,207 @@ declare class UniDropdownComponent extends BaseComponent<UniDropdownOptions> imp
     private get _dropdown();
     private transformOriginMap;
     dropdownClass: _angular_core.Signal<string>;
+    /** The element that receives focus and carries the ARIA popup state. */
+    private get _focusTarget();
     ngOnInit(): void;
+    /**
+     * Returns focus to the trigger when the popover closes while focus was
+     * inside it (or was dropped on <body> by the top layer closing), so
+     * keyboard users are never stranded (WCAG 2.4.3).
+     */
+    private restoreFocus;
     toggleDropdown(): void;
     hideDropdown(): void;
-    private updatePosition;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDropdownComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDropdownComponent, "uni-dropdown, Dropdown", never, { "trigger": { "alias": "trigger"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "paddingVertical": { "alias": "paddingVertical"; "required": false; "isSignal": true; }; "paddingHorizontal": { "alias": "paddingHorizontal"; "required": false; "isSignal": true; }; }, { "dropdownShowing": "dropdownShowing"; "dropdownHiding": "dropdownHiding"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDropdownComponent, "uni-dropdown, Dropdown", never, { "trigger": { "alias": "trigger"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "ariaHasPopup": { "alias": "ariaHasPopup"; "required": false; "isSignal": true; }; "paddingVertical": { "alias": "paddingVertical"; "required": false; "isSignal": true; }; "paddingHorizontal": { "alias": "paddingHorizontal"; "required": false; "isSignal": true; }; }, { "dropdownShowing": "dropdownShowing"; "dropdownHiding": "dropdownHiding"; }, never, ["*"], true, never>;
+}
+
+declare class UniExpandComponent {
+    collapsed: _angular_core.ModelSignal<boolean>;
+    /** Referenced by the controlling toggle's aria-controls. */
+    readonly regionId: string;
+    toggle(): void;
+    expandClassName: string;
+    contentClassName: string;
+    private expand;
+    private collapse;
+    expandAnimation: string;
+    collapseAnimation: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniExpandComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniExpandComponent, "uni-expand, Expand", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+declare class UniExpandToggleComponent {
+    collapsed: _angular_core.ModelSignal<boolean>;
+    /** Id of the Expand region this toggle controls (see UniExpandComponent.regionId). */
+    ariaControls: _angular_core.InputSignal<string>;
+    protected readonly className: _angular_core.Signal<string>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniExpandToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniExpandToggleComponent, "uni-expand-toggle, ExpandToggle", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "ariaControls": { "alias": "ariaControls"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, never, true, never>;
+}
+
+declare class UniExpandAreaComponent {
+    title: _angular_core.InputSignal<string>;
+    initCollapsed: _angular_core.InputSignal<boolean>;
+    padding: _angular_core.InputSignal<NullableSize>;
+    collapsed: _angular_core.OutputEmitterRef<boolean>;
+    toggleRef: _angular_core.Signal<UniExpandToggleComponent>;
+    toggleExpand(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniExpandAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniExpandAreaComponent, "uni-expand-area, ExpandArea", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "initCollapsed": { "alias": "initCollapsed"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsed"; }, never, ["*"], true, never>;
+}
+
+declare class UniFileDropZoneComponent {
+    selectedFile: _angular_core.WritableSignal<File>;
+    selectedFileName: _angular_core.Signal<string>;
+    attachmentState: _angular_core.WritableSignal<"upload">;
+    fileSelectorRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    get fileSelectorElement(): HTMLInputElement;
+    height: _angular_core.InputSignal<string | number>;
+    borderRadius: _angular_core.InputSignal<string>;
+    border: _angular_core.InputSignal<Variant>;
+    padding: _angular_core.InputSignal<NullableSize>;
+    useBrowseButton: _angular_core.InputSignal<boolean>;
+    browseButtonText: _angular_core.InputSignal<string>;
+    allowedFileExtensions: _angular_core.InputSignal<string[]>;
+    label: _angular_core.InputSignal<string>;
+    helpTemplate: _angular_core.InputSignal<TemplateRef<unknown>>;
+    helpTemplateContext: _angular_core.InputSignal<unknown>;
+    fileAttached: _angular_core.OutputEmitterRef<File>;
+    fileRemoved: _angular_core.OutputEmitterRef<void>;
+    /**
+     * The zone acts as the keyboard-reachable file picker only when no browse
+     * button is rendered (nesting a button inside a button-role zone would be
+     * invalid ARIA) and no file is attached yet.
+     */
+    zoneIsInteractive: _angular_core.Signal<boolean>;
+    sanitizedFileExtensions: _angular_core.Signal<string[]>;
+    helpText: _angular_core.Signal<string>;
+    constructor();
+    openFileSelector(): void;
+    selectFiles(fileList: FileList | null): void;
+    onFileInputChange(): void;
+    cancelUpload(): void;
+    removeAttachment(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniFileDropZoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniFileDropZoneComponent, "uni-file-drop-zone", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "useBrowseButton": { "alias": "useBrowseButton"; "required": false; "isSignal": true; }; "browseButtonText": { "alias": "browseButtonText"; "required": false; "isSignal": true; }; "allowedFileExtensions": { "alias": "allowedFileExtensions"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helpTemplate": { "alias": "helpTemplate"; "required": false; "isSignal": true; }; "helpTemplateContext": { "alias": "helpTemplateContext"; "required": false; "isSignal": true; }; }, { "fileAttached": "fileAttached"; "fileRemoved": "fileRemoved"; }, never, never, true, never>;
+}
+
+declare class UniDebounceInputComponent {
+    inputName: _angular_core.InputSignal<string>;
+    inputId: _angular_core.InputSignal<string>;
+    debounceTime: _angular_core.InputSignal<number>;
+    change: _angular_core.OutputEmitterRef<string>;
+    value: _angular_core.WritableSignal<string>;
+    private timeoutId;
+    private lastEmitted;
+    constructor();
+    handleInput(event: Event): void;
+    inputClass: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDebounceInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDebounceInputComponent, "DebounceInput, uni-debounce-input", never, { "inputName": { "alias": "inputName"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, never, true, never>;
 }
 
 declare class UniIconComponent {
     private themeService;
     color: _angular_core.InputSignal<string>;
-    protected _path: string;
-    get className(): string;
-    set name(iconName: keyof Icons);
+    name: _angular_core.InputSignal<string>;
+    protected readonly path: _angular_core.Signal<string>;
+    protected readonly className: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniIconComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniIconComponent, "uni-icon, Icon", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniIconComponent, "uni-icon, Icon", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class UniIconButtonComponent implements OnChanges {
+declare class UniIconButtonComponent {
     private theme;
     config: _angular_core.Signal<_uni_design_system_uni_core.ComponentTheme<unknown>>;
-    iconName?: IconName;
-    symbolName?: string;
-    variant: Variant;
-    size: Size;
-    disable?: boolean;
-    loading?: boolean;
-    opticalSize: number;
-    get className(): string;
-    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Accessible name for the button. Alternative to projecting text content
+     * (`<button icon-button>Close</button>`); one of the two is required for
+     * an icon-only button to be announced correctly.
+     */
+    ariaLabel: _angular_core.InputSignal<string>;
+    iconName: _angular_core.InputSignal<string>;
+    symbolName: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<Variant>;
+    size: _angular_core.InputSignal<Size>;
+    disable: _angular_core.InputSignal<boolean>;
+    loading: _angular_core.InputSignal<boolean>;
+    opticalSize: _angular_core.InputSignal<number>;
+    protected readonly srOnlyClass: string;
+    protected readonly className: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniIconButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniIconButtonComponent, "button[uni-icon-button], button[icon-button]", never, { "iconName": { "alias": "iconName"; "required": false; }; "symbolName": { "alias": "symbolName"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "opticalSize": { "alias": "opticalSize"; "required": false; }; }, {}, never, never, true, [{ directive: typeof RippleDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniIconButtonComponent, "button[uni-icon-button], button[icon-button]", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "symbolName": { "alias": "symbolName"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disable": { "alias": "disable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "opticalSize": { "alias": "opticalSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof RippleDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class UniInputComponent implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** Synced from required() validators by the Signal Forms [field] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /**
+     * Id(s) of external element(s) describing this control — typically your
+     * app-rendered error message — exposed as aria-describedby.
+     */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    label: _angular_core.InputSignal<string>;
+    placeholder: _angular_core.InputSignal<string>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    markAsTouched(): void;
+    handleInput(event: Event): void;
+    inputClass: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniInputComponent, "uni-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["pre-input", "post-input"], true, never>;
+}
+
+interface UniInputBoxOptions {
+    color: ContainerColorToken;
+    disabledColor: ContainerColorToken;
+    errorColor: ContainerColorToken;
+    border: Border;
+    errorBorder: Border;
+    borderRadius: Radius;
+    transitionSpeed: number;
+    shadow?: Shadow;
+    errorShadow?: Shadow;
+    height?: string | number;
+    paddingLeft: OptionalSize;
+    typeFace: Typeface;
+    textColor: ColorKey;
+    disabledTextColor: ColorKey;
+    focusOutline: string;
+    focusOutlineOffset: number;
+}
+
+declare class UniInputBoxComponent extends BaseComponent<UniInputBoxOptions> {
+    protected readonly className: string;
+    disabled: _angular_core.InputSignal<boolean>;
+    error: _angular_core.InputSignal<boolean>;
+    minWidth: _angular_core.InputSignal<string>;
+    protected readonly color: _angular_core.Signal<_uni_design_system_uni_core.ContainerColorToken>;
+    protected readonly border: _angular_core.Signal<string>;
+    protected readonly shadow: _angular_core.Signal<string>;
+    protected readonly inputBoxClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniInputBoxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniInputBoxComponent, "uni-input-box", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class UniJsonViewComponent {
+    json: _angular_core.InputSignal<unknown>;
+    rows: _angular_core.InputSignal<number>;
+    fontSize: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    selectOnClick: _angular_core.InputSignal<boolean>;
+    jsonString: _angular_core.Signal<string>;
+    className: _angular_core.Signal<string>;
+    selectContents(jsonArea: HTMLTextAreaElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniJsonViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniJsonViewComponent, "uni-json-view", never, { "json": { "alias": "json"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "fontSize": { "alias": "fontSize"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "selectOnClick": { "alias": "selectOnClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class UniBoxComponent {
@@ -510,7 +976,7 @@ declare class UniBoxComponent {
     textAlign: _angular_core.InputSignal<OptionalTextAlign>;
     wrapItems: _angular_core.InputSignal<OptionalWrap>;
     zIndex: _angular_core.InputSignal<ZIndexableElements>;
-    get boxClassName(): string;
+    protected readonly boxClassName: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniBoxComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniBoxComponent, "div[uni-box-layout], Box, div[box-layout]", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "borderRadiusLeft": { "alias": "borderRadiusLeft"; "required": false; "isSignal": true; }; "borderRadiusRight": { "alias": "borderRadiusRight"; "required": false; "isSignal": true; }; "borderRadiusTop": { "alias": "borderRadiusTop"; "required": false; "isSignal": true; }; "borderRadiusBottom": { "alias": "borderRadiusBottom"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "paddingHorizontal": { "alias": "paddingHorizontal"; "required": false; "isSignal": true; }; "paddingVertical": { "alias": "paddingVertical"; "required": false; "isSignal": true; }; "paddingLeft": { "alias": "paddingLeft"; "required": false; "isSignal": true; }; "paddingRight": { "alias": "paddingRight"; "required": false; "isSignal": true; }; "paddingTop": { "alias": "paddingTop"; "required": false; "isSignal": true; }; "paddingBottom": { "alias": "paddingBottom"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; "borderTop": { "alias": "borderTop"; "required": false; "isSignal": true; }; "borderBottom": { "alias": "borderBottom"; "required": false; "isSignal": true; }; "borderLeft": { "alias": "borderLeft"; "required": false; "isSignal": true; }; "borderRight": { "alias": "borderRight"; "required": false; "isSignal": true; }; "dashBorder": { "alias": "dashBorder"; "required": false; "isSignal": true; }; "alignSelf": { "alias": "alignSelf"; "required": false; "isSignal": true; }; "alignItems": { "alias": "alignItems"; "required": false; "isSignal": true; }; "alignContent": { "alias": "alignContent"; "required": false; "isSignal": true; }; "justifyContent": { "alias": "justifyContent"; "required": false; "isSignal": true; }; "grow": { "alias": "grow"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "ignoreDir": { "alias": "ignoreDir"; "required": false; "isSignal": true; }; "gridArea": { "alias": "gridArea"; "required": false; "isSignal": true; }; "gridColumn": { "alias": "gridColumn"; "required": false; "isSignal": true; }; "gridRow": { "alias": "gridRow"; "required": false; "isSignal": true; }; "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; "elevation": { "alias": "elevation"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "fullHeight": { "alias": "fullHeight"; "required": false; "isSignal": true; }; "flexDirection": { "alias": "flexDirection"; "required": false; "isSignal": true; }; "textAlign": { "alias": "textAlign"; "required": false; "isSignal": true; }; "wrapItems": { "alias": "wrapItems"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -525,23 +991,22 @@ declare class UniCenterComponent extends UniBoxComponent {
 }
 
 declare class UniGridAreaComponent {
-    area: string;
-    get className(): string;
+    area: _angular_core.InputSignal<string>;
+    protected readonly className: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniGridAreaComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniGridAreaComponent, "GridArea", never, { "area": { "alias": "area"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniGridAreaComponent, "GridArea", never, { "area": { "alias": "area"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class UniGridComponent extends UniBoxComponent {
     display: _angular_core.InputSignal<OptionalDisplay>;
-    constructor();
-    templateAreas?: string;
-    templateColumns?: string;
-    templateRows?: string;
-    outline?: Thickness;
-    outlineColor?: Variant;
-    get className(): string;
+    templateAreas: _angular_core.InputSignal<string>;
+    templateColumns: _angular_core.InputSignal<string>;
+    templateRows: _angular_core.InputSignal<string>;
+    outline: _angular_core.InputSignal<Thickness>;
+    outlineColor: _angular_core.InputSignal<Variant>;
+    protected readonly gridClassName: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniGridComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniGridComponent, "div[uni-grid-layout], Grid, div[grid-layout]", never, { "display": { "alias": "display"; "required": false; "isSignal": true; }; "templateAreas": { "alias": "templateAreas"; "required": false; }; "templateColumns": { "alias": "templateColumns"; "required": false; }; "templateRows": { "alias": "templateRows"; "required": false; }; "outline": { "alias": "outline"; "required": false; }; "outlineColor": { "alias": "outlineColor"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniGridComponent, "div[uni-grid-layout], Grid, div[grid-layout]", never, { "display": { "alias": "display"; "required": false; "isSignal": true; }; "templateAreas": { "alias": "templateAreas"; "required": false; "isSignal": true; }; "templateColumns": { "alias": "templateColumns"; "required": false; "isSignal": true; }; "templateRows": { "alias": "templateRows"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "outlineColor": { "alias": "outlineColor"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class UniRowComponent extends UniBoxComponent {
@@ -587,18 +1052,115 @@ interface MenuItemWithTemplate<T = any> extends BaseMenuItem {
 type MenuItem<T = any> = MenuItemWithLabel | MenuItemWithTemplate<T>;
 
 declare class UniMenuComponent {
-    private cdr;
     menuItems: _angular_core.InputSignal<MenuItem[]>;
     activeItem: _angular_core.InputSignal<MenuItem>;
-    placement: _angular_core.InputSignal<Placement$1>;
+    placement: _angular_core.InputSignal<Placement>;
     menuItemClicked: _angular_core.OutputEmitterRef<MenuItem>;
     TriggerClassName: string;
-    get className(): string;
+    private itemComponents;
+    private dropdownComponent;
+    /** Which item receives focus when the menu opens (ArrowUp opens onto the last item). */
+    private pendingFocus;
+    protected readonly className: _angular_core.Signal<string>;
     handleMenuItemClick(item: MenuItem, dropdown: UniDropdownComponent): void;
+    /** Enabled items participating in keyboard navigation. */
+    private get navigableItems();
+    onOpened(): void;
+    onTriggerKeydown(event: KeyboardEvent): void;
+    onMenuKeydown(event: KeyboardEvent, dropdown: UniDropdownComponent): void;
+    /** First-character matching, starting after the focused item and wrapping. */
+    private typeahead;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniMenuComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniMenuComponent, "Menu, uni-menu", never, { "menuItems": { "alias": "menuItems"; "required": true; "isSignal": true; }; "activeItem": { "alias": "activeItem"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, { "menuItemClicked": "menuItemClicked"; }, never, ["*"], true, never>;
 }
 
+declare class UniMultiSelectComponent<T = unknown> {
+    options: _angular_core.InputSignal<Option<T>[]>;
+    selections: _angular_core.InputSignal<T[]>;
+    updates: _angular_core.OutputEmitterRef<T[]>;
+    flexDirection: _angular_core.InputSignal<"column" | "row" | "column-reverse" | "row-reverse">;
+    checkboxGap: _angular_core.InputSignal<NullableSize>;
+    protected readonly values: _angular_core.Signal<unknown[]>;
+    protected readonly optionsWithSelections: _angular_core.Signal<Option<T>[]>;
+    protected readonly className: string;
+    handleCheck(checked: boolean, value: T): void;
+    selectAll(): void;
+    deselectAll(): void;
+    optionWrapper: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniMultiSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniMultiSelectComponent<any>, "uni-multi-select, MultiSelect", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "selections": { "alias": "selections"; "required": false; "isSignal": true; }; "flexDirection": { "alias": "flexDirection"; "required": false; "isSignal": true; }; "checkboxGap": { "alias": "checkboxGap"; "required": false; "isSignal": true; }; }, { "updates": "updates"; }, never, never, true, never>;
+}
+
+interface UniMultiSelectDropdownOptions {
+    textRole: Typeface;
+    textColor: TextColor;
+    placeholderTextColor: TextColor;
+    dividerBorder: Border;
+    searchInputBorder: Border;
+    searchInputBorderRadius: Radius;
+    focusOutline: string;
+    focusOutlineOffset: number;
+}
+
+declare class UniMultiSelectDropdownComponent<T = unknown> extends BaseComponent<UniMultiSelectDropdownOptions> implements FormValueControl<T[]> {
+    protected readonly className: string;
+    readonly value: _angular_core.ModelSignal<T[]>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** Synced from required() validators by the Signal Forms [field] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /**
+     * Id(s) of external element(s) describing this control — typically your
+     * app-rendered error message — exposed as aria-describedby.
+     */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<Options<T>>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly filteredOptions: _angular_core.Signal<Options<T>>;
+    readonly selectedLabelsText: _angular_core.Signal<string>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected readonly textColor: _angular_core.Signal<_uni_design_system_uni_core.TextColor>;
+    triggerClass: string;
+    protected readonly searchInputClass: _angular_core.Signal<string>;
+    protected handleQueryInput(event: Event): void;
+    selectAll(): void;
+    deselectAll(): void;
+    protected isOptionSelected(option: Option<T>): _angular_core.Signal<boolean>;
+    toggleOption(option: Option<T>, checked: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniMultiSelectDropdownComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniMultiSelectDropdownComponent<any>, "uni-multi-select-dropdown, MultiSelectDropdown", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+interface UniNotificationBadgeOptions {
+    borderRadius?: RadiiSize;
+    offset?: number;
+    typeface: Typeface;
+}
+
+declare class UniNotificationBadgeComponent extends BaseComponent<UniNotificationBadgeOptions> {
+    count: _angular_core.InputSignal<number>;
+    maxCount: _angular_core.InputSignal<number>;
+    badgeVariant: _angular_core.InputSignal<"dot" | "count" | "pill">;
+    color: _angular_core.InputSignal<Variant>;
+    position: _angular_core.InputSignal<"top-right" | "top-left" | "bottom-right" | "bottom-left">;
+    show: _angular_core.InputSignal<boolean>;
+    /**
+     * Screen-reader text for the badge (e.g. "5 unread messages"). Without it
+     * a sensible default is announced; a bare number or dot carries no meaning.
+     */
+    ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly srOnlyClass: string;
+    protected readonly announcement: _angular_core.Signal<string>;
+    displayValue: _angular_core.Signal<string>;
+    shouldShow: _angular_core.Signal<boolean>;
+    protected readonly className: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniNotificationBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniNotificationBadgeComponent, "uni-notification-badge", never, { "count": { "alias": "count"; "required": false; "isSignal": true; }; "maxCount": { "alias": "maxCount"; "required": false; "isSignal": true; }; "badgeVariant": { "alias": "badgeVariant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 interface UniAlertOptions {
     defaultVariant: Variant;
     borderRadius: Radius;
@@ -612,7 +1174,7 @@ declare class UniAlertComponent extends BaseComponent<UniAlertOptions> implement
     iconName: _angular_core.InputSignal<string>;
     symbolName: _angular_core.InputSignal<string>;
     useVariant: _angular_core.InputSignal<boolean>;
-    showing: EventEmitter<boolean>;
+    showing: _angular_core.OutputEmitterRef<boolean>;
     alertRef?: ElementRef<HTMLDialogElement>;
     private readonly alertState;
     private readonly effectiveVariant;
@@ -629,10 +1191,10 @@ declare class UniAlertComponent extends BaseComponent<UniAlertOptions> implement
 
 declare class ConfirmationDialogComponent {
     show: _angular_core.InputSignal<boolean>;
-    confirmation?: Confirmation;
-    showing: EventEmitter<any>;
+    confirmation: _angular_core.InputSignal<Confirmation>;
+    showing: _angular_core.OutputEmitterRef<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmationDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmationDialogComponent, "uni-confirmation-dialog, Confirmation", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "confirmation": { "alias": "confirmation"; "required": false; }; }, { "showing": "showing"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmationDialogComponent, "uni-confirmation-dialog, Confirmation", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "confirmation": { "alias": "confirmation"; "required": false; "isSignal": true; }; }, { "showing": "showing"; }, never, never, true, never>;
 }
 
 declare class NotificationsComponent {
@@ -660,7 +1222,7 @@ interface UniSnackbarOptions {
     autoCloseDelay: number;
 }
 
-declare class UniSnackbarComponent extends BaseComponent<UniSnackbarOptions> implements AfterViewInit, OnChanges {
+declare class UniSnackbarComponent extends BaseComponent<UniSnackbarOptions> implements AfterViewInit {
     timer: {
         start: (durationMs: number, onComplete?: () => void) => void;
         pause: () => void;
@@ -671,20 +1233,20 @@ declare class UniSnackbarComponent extends BaseComponent<UniSnackbarOptions> imp
         isActive: _angular_core.Signal<boolean>;
         secondsRemaining: _angular_core.Signal<number>;
     };
-    snackbarClass?: string;
-    show?: boolean;
+    /** Two-way bindable open state: [(show)]. */
+    show: _angular_core.ModelSignal<boolean>;
     iconName: _angular_core.InputSignal<string>;
     symbolName: _angular_core.InputSignal<string>;
     timeout: _angular_core.InputSignal<string | number>;
     actionLabel: _angular_core.InputSignal<string>;
     useVariant: _angular_core.InputSignal<boolean>;
-    action: EventEmitter<any>;
-    showing: EventEmitter<any>;
-    snackbarRef?: ElementRef;
+    action: _angular_core.OutputEmitterRef<void>;
+    showing: _angular_core.OutputEmitterRef<boolean>;
+    snackbarRef: _angular_core.Signal<ElementRef<any>>;
     private get _snackbar();
     constructor();
+    protected readonly snackbarClass: _angular_core.Signal<string>;
     fadeOut: string;
-    ngOnChanges(changes: SimpleChanges): void;
     ngAfterViewInit(): void;
     private get _timeout();
     open(): void;
@@ -692,7 +1254,235 @@ declare class UniSnackbarComponent extends BaseComponent<UniSnackbarOptions> imp
     protected pauseTimer(): void;
     protected resumeTimer(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniSnackbarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSnackbarComponent, "uni-snackbar, Snackbar", never, { "show": { "alias": "show"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "symbolName": { "alias": "symbolName"; "required": false; "isSignal": true; }; "timeout": { "alias": "timeout"; "required": false; "isSignal": true; }; "actionLabel": { "alias": "actionLabel"; "required": false; "isSignal": true; }; "useVariant": { "alias": "useVariant"; "required": false; "isSignal": true; }; }, { "action": "action"; "showing": "showing"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSnackbarComponent, "uni-snackbar, Snackbar", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "symbolName": { "alias": "symbolName"; "required": false; "isSignal": true; }; "timeout": { "alias": "timeout"; "required": false; "isSignal": true; }; "actionLabel": { "alias": "actionLabel"; "required": false; "isSignal": true; }; "useVariant": { "alias": "useVariant"; "required": false; "isSignal": true; }; }, { "show": "showChange"; "action": "action"; "showing": "showing"; }, never, ["*"], true, never>;
+}
+
+interface UniPaginatorOptions {
+    gap: NullableSize;
+    textRole: TextRole;
+    inputBorder: Border;
+    inputBorderRadius: Radius;
+    pageBorder: Border;
+    pageBorderRadius: Radius;
+    currentPageBorder: Border;
+    currentPageBorderRadius: Radius;
+}
+
+declare class UniPaginatorComponent<T> extends BaseComponent<UniPaginatorOptions> {
+    datasource: _angular_core.InputSignal<UniDatasource<T>>;
+    initPageSize: _angular_core.InputSignal<number>;
+    showPageSize: _angular_core.InputSignal<boolean>;
+    showPageJumper: _angular_core.InputSignal<boolean>;
+    showPageNumbers: _angular_core.InputSignal<boolean>;
+    constructor();
+    protected readonly inputClass: _angular_core.Signal<string>;
+    protected readonly pageClass: _angular_core.Signal<string>;
+    updatePageSize(event: Event): void;
+    jumpToPage(event: Event): void;
+    isNumber(page: unknown): page is number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniPaginatorComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniPaginatorComponent<any>, "uni-paginator, Paginator", never, { "datasource": { "alias": "datasource"; "required": false; "isSignal": true; }; "initPageSize": { "alias": "initPageSize"; "required": false; "isSignal": true; }; "showPageSize": { "alias": "showPageSize"; "required": false; "isSignal": true; }; "showPageJumper": { "alias": "showPageJumper"; "required": false; "isSignal": true; }; "showPageNumbers": { "alias": "showPageNumbers"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UniPopoverComponent {
+    private renderer;
+    private theme;
+    placement: _angular_core.InputSignal<Placement>;
+    /** Light-dismiss on outside click / Escape (native popover="auto"). */
+    autoClose: _angular_core.InputSignal<boolean>;
+    readonly panelId: string;
+    private readonly anchorName;
+    private readonly showing;
+    private triggerRef;
+    private panelRef;
+    constructor();
+    protected onToggle(event: Event): void;
+    showPopover(): void;
+    hidePopover(): void;
+    togglePopover(event: MouseEvent): void;
+    protected readonly triggerClassName: string;
+    protected readonly popoverClassName: _angular_core.Signal<string>;
+    protected readonly arrowClassName: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniPopoverComponent, "uni-popover, Popover", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "autoClose": { "alias": "autoClose"; "required": false; "isSignal": true; }; }, {}, never, ["[trigger]", "*"], true, never>;
+}
+
+declare class UniProgressBarComponent {
+    theme: ThemeService;
+    palette: _angular_core.Signal<Partial<Record<string, string>>>;
+    width: _angular_core.InputSignal<number>;
+    height: _angular_core.InputSignal<number>;
+    percent: _angular_core.InputSignal<number>;
+    /** Accessible name describing what is progressing (e.g. "Upload progress"). */
+    ariaLabel: _angular_core.InputSignal<string>;
+    stroke: number;
+    protected readonly className: _angular_core.Signal<string>;
+    protected readonly Math: Math;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniProgressBarComponent, "uni-progress-bar, ProgressBar", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "percent": { "alias": "percent"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UniProgressGaugeComponent extends BaseComponent {
+    percent: _angular_core.InputSignal<number>;
+    /** Accessible name describing what is progressing. */
+    ariaLabel: _angular_core.InputSignal<string>;
+    textStyle: _angular_core.Signal<string | number | _uni_design_system_uni_core.StyleExpression>;
+    private progress;
+    protected readonly className: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniProgressGaugeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniProgressGaugeComponent, "uni-progress-gauge, ProgressGauge", never, { "percent": { "alias": "percent"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface UniRadioOption {
+    /**
+     * The label displayed for this radio option
+     */
+    label: string;
+    /**
+     * The value associated with this radio option
+     */
+    value: string;
+    /**
+     * Whether this option is disabled
+     */
+    disabled?: boolean;
+}
+interface UniRadioOptions {
+    /**
+     * The size of the radio buttons
+     */
+    size: number;
+}
+
+declare class UniRadioComponent extends BaseComponent<UniRadioOptions> implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** Synced from required() validators by the Signal Forms [field] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /**
+     * Id(s) of external element(s) describing this control — typically your
+     * app-rendered error message — exposed as aria-describedby.
+     */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<UniRadioOption[]>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    /** Links the group label to the radiogroup container. */
+    protected readonly groupLabelId: string;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    markAsTouched(): void;
+    private readonly metrics;
+    protected readonly radioGroupClass: string;
+    protected readonly radioOptionClass: _angular_core.Signal<string>;
+    protected readonly radioInputClass: _angular_core.Signal<string>;
+    handleRadioChange(optionValue: string): void;
+    getThemeColor(token: ColorToken): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniRadioComponent, "uni-radio, Radio", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Visual style of the scrollbar.
+ * - `compact`: thin overlay-style scrollbar.
+ * - `standard`: full-size scrollbar with a bordered track gutter.
+ */
+type ScrollbarAppearance = 'standard' | 'compact';
+
+type OptionalValue = string | number | undefined;
+/**
+ * Native scroll area with theme-driven scrollbar styling.
+ *
+ * Scrollbars are styled entirely through Emotion-generated CSS:
+ * `::-webkit-scrollbar` rules cover Chromium/Safari, with a
+ * `scrollbar-width`/`scrollbar-color` fallback for Firefox.
+ */
+declare class UniScrollAreaComponent {
+    theme: ThemeService;
+    isVerticallyScrollable: _angular_core.WritableSignal<boolean>;
+    viewport: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    content: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    color: _angular_core.InputSignal<ContainerColorToken>;
+    borderRadius: _angular_core.InputSignal<string>;
+    padding: _angular_core.InputSignal<OptionalSize>;
+    paddingHorizontal: _angular_core.InputSignal<OptionalSize>;
+    paddingVertical: _angular_core.InputSignal<OptionalSize>;
+    paddingLeft: _angular_core.InputSignal<OptionalSize>;
+    paddingRight: _angular_core.InputSignal<OptionalSize>;
+    paddingTop: _angular_core.InputSignal<OptionalSize>;
+    paddingBottom: _angular_core.InputSignal<OptionalSize>;
+    border: _angular_core.InputSignal<Variant>;
+    height: _angular_core.InputSignal<OptionalValue>;
+    width: _angular_core.InputSignal<OptionalValue>;
+    appearance: _angular_core.InputSignal<ScrollbarAppearance>;
+    autoHeightDisabled: _angular_core.InputSignal<boolean>;
+    verticalScrollPadding: _angular_core.InputSignal<number>;
+    scrollable: _angular_core.OutputEmitterRef<boolean>;
+    scrollToBottom(): void;
+    scrollToTop(): void;
+    protected readonly className: _angular_core.Signal<string>;
+    protected viewportClassName: _angular_core.Signal<string>;
+    protected contentClassName: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniScrollAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniScrollAreaComponent, "div[uni-scroll-area], ScrollArea, div[scroll-area]", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "paddingHorizontal": { "alias": "paddingHorizontal"; "required": false; "isSignal": true; }; "paddingVertical": { "alias": "paddingVertical"; "required": false; "isSignal": true; }; "paddingLeft": { "alias": "paddingLeft"; "required": false; "isSignal": true; }; "paddingRight": { "alias": "paddingRight"; "required": false; "isSignal": true; }; "paddingTop": { "alias": "paddingTop"; "required": false; "isSignal": true; }; "paddingBottom": { "alias": "paddingBottom"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "autoHeightDisabled": { "alias": "autoHeightDisabled"; "required": false; "isSignal": true; }; "verticalScrollPadding": { "alias": "verticalScrollPadding"; "required": false; "isSignal": true; }; }, { "scrollable": "scrollable"; }, never, ["*"], true, never>;
+}
+
+declare class UniSearchInputComponent {
+    label: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    change: _angular_core.OutputEmitterRef<string>;
+    search: _angular_core.OutputEmitterRef<string>;
+    protected readonly className: _angular_core.Signal<string>;
+    handleSearchInput(searchInput: string): void;
+    handleSearch(searchInput: string | undefined): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniSearchInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSearchInputComponent, "SearchInput, uni-search-input", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "change": "change"; "search": "search"; }, never, never, true, never>;
+}
+
+declare class UniSelectComponent<T> implements FormValueControl<T | null> {
+    readonly value: _angular_core.ModelSignal<T>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** Synced from required() validators by the Signal Forms [field] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /**
+     * Id(s) of external element(s) describing this control — typically your
+     * app-rendered error message — exposed as aria-describedby.
+     */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<Options<T>>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Accessible name for the select; a placeholder is not a label. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly UNSELECTED = -1;
+    /**
+     * We use the index as the HTML value to avoid issues with
+     * stringifying complex objects or duplicate labels.
+     */
+    protected readonly currentSelectedIndex: _angular_core.Signal<string | -1>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected handleSelectChange(event: Event): void;
+    selectClass: string;
+    arrowClass: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSelectComponent<any>, "uni-select, SelectInput", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class UniSortHeaderComponent<T> {
+    column: _angular_core.InputSignal<keyof T>;
+    datasource: _angular_core.InputSignal<UniDatasource<T>>;
+    protected readonly buttonClass: string;
+    direction: _angular_core.Signal<SortDirection>;
+    protected readonly className: _angular_core.Signal<string>;
+    cycleSort(): void;
+    sortDatasource(direction: SortDirection): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniSortHeaderComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSortHeaderComponent<any>, "uni-sort-header", never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; "datasource": { "alias": "datasource"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 type SymbolFill = 1 | 0;
@@ -711,11 +1501,20 @@ declare class UniSymbolComponent extends BaseComponent<SymbolOptions> {
     weight: _angular_core.InputSignal<SymbolWeight>;
     grade: _angular_core.InputSignal<SymbolGrade>;
     opticalSize: _angular_core.InputSignal<number>;
-    get className(): string;
+    protected readonly className: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniSymbolComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSymbolComponent, "uni-symbol, Symbol", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "grade": { "alias": "grade"; "required": false; "isSignal": true; }; "opticalSize": { "alias": "opticalSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+declare class UniTagComponent {
+    label: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<string | number>;
+    close: _angular_core.OutputEmitterRef<string | number>;
+    handleClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniTagComponent, "Tag, uni-tag", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
+}
+
 declare class UniTextComponent {
     theme: ThemeService;
     typeface: _angular_core.InputSignal<string>;
@@ -725,11 +1524,94 @@ declare class UniTextComponent {
     nowrap: _angular_core.InputSignal<boolean>;
     maxWidth: _angular_core.InputSignal<number>;
     ellipsis: _angular_core.InputSignal<boolean>;
-    get className(): string;
+    protected readonly className: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniTextComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniTextComponent, "uni-text, Text", never, { "typeface": { "alias": "typeface"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "nowrap": { "alias": "nowrap"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "ellipsis": { "alias": "ellipsis"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+interface Preset {
+    label: string;
+    config: BrandPaletteConfig;
+}
+declare class UniThemeBuilderComponent {
+    protected theme: ThemeService;
+    protected readonly schemes: ColorScheme[];
+    protected readonly categories: ColorCategory[];
+    protected readonly variants: Variant[];
+    protected readonly sizes: readonly ["sm", "md", "lg", "xl"];
+    protected readonly swatches: {
+        label: string;
+        token: ColorToken;
+        on: ColorToken;
+    }[];
+    protected readonly presets: Preset[];
+    protected seed: _angular_core.WritableSignal<string>;
+    protected scheme: _angular_core.WritableSignal<ColorScheme>;
+    protected category: _angular_core.WritableSignal<ColorCategory>;
+    protected floor: _angular_core.WritableSignal<number>;
+    protected mode: _angular_core.WritableSignal<"light" | "dark">;
+    protected pinPrimary: _angular_core.WritableSignal<boolean>;
+    protected primaryHex: _angular_core.WritableSignal<string>;
+    protected pinSecondary: _angular_core.WritableSignal<boolean>;
+    protected secondaryHex: _angular_core.WritableSignal<string>;
+    /** Soft brand targets carried by the active preset (cleared on seed edits). */
+    protected targets: _angular_core.WritableSignal<Partial<Record<_uni_design_system_uni_core.BrandRole, string>>>;
+    constructor();
+    protected config: _angular_core.Signal<BrandPaletteConfig>;
+    protected snippet: _angular_core.Signal<string>;
+    protected color(token: ColorToken): string;
+    private apply;
+    protected setSeed(v: string): void;
+    protected setScheme(v: ColorScheme): void;
+    protected setCategory(v: ColorCategory): void;
+    protected setFloor(v: string): void;
+    protected setMode(v: 'light' | 'dark'): void;
+    protected setPinPrimary(v: boolean): void;
+    protected setPrimaryHex(v: string): void;
+    protected setPinSecondary(v: boolean): void;
+    protected setSecondaryHex(v: string): void;
+    protected applyPreset(config: BrandPaletteConfig): void;
+    protected reset(): void;
+    private c;
+    protected shell: _angular_core.Signal<string>;
+    protected controls: _angular_core.Signal<string>;
+    protected preview: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniThemeBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniThemeBuilderComponent, "uni-theme-builder", never, {}, {}, never, never, true, never>;
+}
+
+interface UniToggleOptions {
+    /**
+     * The size of the toggle switch
+     */
+    size: number;
+}
+
+declare class UniToggleComponent extends BaseComponent<UniToggleOptions> implements FormCheckboxControl {
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** Synced from required() validators by the Signal Forms [field] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /**
+     * Id(s) of external element(s) describing this control — typically your
+     * app-rendered error message — exposed as aria-describedby.
+     */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    markAsTouched(): void;
+    handleChange(event: Event): void;
+    private readonly metrics;
+    protected readonly toggleLabel: _angular_core.Signal<string>;
+    protected readonly toggleInput: _angular_core.Signal<string>;
+    getThemeColor(token: ColorToken): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniToggleComponent, "uni-toggle, Toggle", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
 interface UniTooltipOptions {
     color?: ContainerColorToken;
     border?: Border;
@@ -738,41 +1620,58 @@ interface UniTooltipOptions {
     typeface: TextRole;
 }
 
-type Placement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'right-start' | 'bottom-start' | 'left-start' | 'top-end' | 'right-end' | 'bottom-end' | 'left-end';
-
-declare class UniTooltipComponent extends BaseComponent<UniTooltipOptions> implements OnDestroy {
+declare class UniTooltipComponent extends BaseComponent<UniTooltipOptions> {
     private elRef;
     private renderer;
     private timer;
-    hoverDelayMs: _angular_core.WritableSignal<number>;
     isMouseInside: _angular_core.WritableSignal<boolean>;
-    private tooltip;
-    private arrow;
+    /** Whether the bubble is currently shown (or fading out). */
+    private readonly visible;
+    readonly tooltipId: string;
+    private readonly anchorName;
     hoverDelay: _angular_core.InputSignal<number>;
     label: _angular_core.InputSignal<string>;
     placement: _angular_core.InputSignal<Placement>;
     inlineText: _angular_core.InputSignal<boolean>;
-    appendToBody?: boolean;
+    /** @deprecated The tooltip renders in the native top layer; ignored. */
+    appendToBody: _angular_core.InputSignal<boolean>;
+    private tipRef;
     constructor();
+    onFocusIn(event: FocusEvent): void;
+    onFocusOut(): void;
+    onEscape(event: Event): void;
     toggleTooltip(): void;
     mouseenter(): void;
     mouseleave(): void;
     showTooltip(): void;
     hideTooltip(): void;
-    get className(): string;
+    protected onAnimationEnd(event: AnimationEvent): void;
+    protected readonly className: _angular_core.Signal<string>;
     private tooltipFadeIn;
     private tooltipFadeOut;
-    private tooltipClassName;
-    private arrowClassName;
-    private createTooltip;
-    private createArrow;
-    private setPosition;
-    private initializeTooltip;
-    private destroyTooltip;
-    ngOnDestroy(): void;
+    protected readonly tooltipClassName: _angular_core.Signal<string>;
+    protected readonly arrowClassName: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniTooltipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniTooltipComponent, "uni-tooltip, Tooltip", never, { "hoverDelay": { "alias": "hoverDelay"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "inlineText": { "alias": "inlineText"; "required": false; "isSignal": true; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniTooltipComponent, "uni-tooltip, Tooltip", never, { "hoverDelay": { "alias": "hoverDelay"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "inlineText": { "alias": "inlineText"; "required": false; "isSignal": true; }; "appendToBody": { "alias": "appendToBody"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class BodyRenderDirective implements OnInit {
+    private el;
+    private renderer;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BodyRenderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BodyRenderDirective, "[uniBodyRender]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DragAndDropDirective {
+    onFileDropped: _angular_core.OutputEmitterRef<FileList>;
+    protected workspaceOpacity: _angular_core.WritableSignal<string>;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragAndDropDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DragAndDropDirective, "[uni-drag-n-drop], [dragAndDrop]", never, {}, { "onFileDropped": "onFileDropped"; }, never, never, true, never>;
 }
 
-export { ConfirmationDialogComponent, LocalStorageService, NotificationService, NotificationsComponent, RippleDirective, ThemeService, UNI_THEMES, UniAlertComponent, UniBadgeComponent, UniBaseDatasource, UniBoxComponent, UniButtonComponent, UniCardComponent, UniCardContentComponent, UniCardHeaderComponent, UniCenterComponent, UniDialogButtonsComponent, UniDialogComponent, UniDialogHeaderComponent, UniDividerComponent, UniDropdownComponent, UniGridAreaComponent, UniGridComponent, UniIconButtonComponent, UniIconComponent, UniMenuComponent, UniRecordDatasource, UniRowComponent, UniServerSideDatasource, UniSnackbarComponent, UniStackComponent, UniSymbolComponent, UniTextComponent, UniTooltipComponent, UniWrapComponent, useTimer };
-export type { Alert, Confirmation, DataLoader, MenuItem, MenuItemWithLabel, MenuItemWithTemplate, Option, Options, PageRequest, PageResponse, Snackbar, Sort, SortDirection, UniDatasource };
+export { BodyRenderDirective, ConfirmationDialogComponent, DragAndDropDirective, FOCUSABLE_SELECTOR, LocalStorageService, NotificationService, NotificationsComponent, RippleDirective, ThemeService, UNI_THEMES, UniAlertComponent, UniBackgroundComponent, UniBadgeComponent, UniBaseDatasource, UniBoxComponent, UniButtonComponent, UniButtonGroupComponent, UniCardComponent, UniCardContentComponent, UniCardHeaderComponent, UniCenterComponent, UniCheckboxComponent, UniDataSearchComponent, UniDataTableComponent, UniDebounceInputComponent, UniDialogButtonsComponent, UniDialogComponent, UniDialogHeaderComponent, UniDividerComponent, UniDropdownComponent, UniExpandAreaComponent, UniExpandComponent, UniExpandToggleComponent, UniFileDropZoneComponent, UniGridAreaComponent, UniGridComponent, UniIconButtonComponent, UniIconComponent, UniInputBoxComponent, UniInputComponent, UniJsonViewComponent, UniMenuComponent, UniMultiSelectComponent, UniMultiSelectDropdownComponent, UniNotificationBadgeComponent, UniPaginatorComponent, UniPopoverComponent, UniProgressBarComponent, UniProgressGaugeComponent, UniRadioComponent, UniRecordDatasource, UniRowComponent, UniScrollAreaComponent, UniSearchInputComponent, UniSelectComponent, UniServerSideDatasource, UniSnackbarComponent, UniSortHeaderComponent, UniStackComponent, UniSymbolComponent, UniTagComponent, UniTextComponent, UniThemeBuilderComponent, UniToggleComponent, UniTooltipComponent, UniWrapComponent, acceptableFile, anchorArrowStyles, anchorStyles, getFileExtension, motionSafe, newAnchorName, resolveFocusTarget, uniqueId, useTimer, visuallyHidden };
+export type { Alert, AnchorOffset, BrandPaletteConfig, ButtonGroupConfig, ButtonGroupItem, ColumnDefinition, Confirmation, DataLoader, ImagePosition, MenuItem, MenuItemWithLabel, MenuItemWithTemplate, Option, Options, PageRequest, PageResponse, Placement, ScrollbarAppearance, Snackbar, Sort, SortDirection, UniCheckboxOptions, UniDataSearchOptions, UniDataTableOptions, UniDatasource, UniInputBoxOptions, UniMultiSelectDropdownOptions, UniNotificationBadgeOptions, UniPaginatorOptions, UniRadioOption, UniRadioOptions, UniToggleOptions };