@elvora/angular 1.0.0-rc.1

package/dist/index.d.cts

@@ -0,0 +1,2636 @@
+import * as _elvora_core from '@elvora/core';
+import { ElvoraVariant, ElvoraSize, ElvoraTheme, ElvoraStatus, Orientation, ElvoraTone, Placement, ErrorCorrection, Direction as Direction$1 } from '@elvora/core';
+export { Direction, ElvoraSize, ElvoraStatus, ElvoraTheme, ElvoraTone, ElvoraVariant, IntentScale, Orientation, Placement, ThemeColors } from '@elvora/core';
+import * as _angular_core from '@angular/core';
+import { EventEmitter, Signal, OnDestroy, TemplateRef, AfterContentInit, ElementRef, AfterViewInit, InjectionToken } from '@angular/core';
+import * as _elvora_icons from '@elvora/icons';
+import { IconName } from '@elvora/icons';
+
+/**
+ * Angular Elvora Button — standalone component.
+ *
+ * Usage:
+ * ```html
+ * <elvora-button variant="primary" size="md" (press)="onClick()">
+ *   Click me
+ * </elvora-button>
+ * ```
+ *
+ * Implements WAI-ARIA Button pattern; identical visual contract as the React,
+ * RN, and Vue adapters.
+ */
+declare class ElvoraButton {
+    private readonly themeService;
+    variant: ElvoraVariant;
+    size: ElvoraSize;
+    intent: keyof ElvoraTheme['colors']['intent'] | undefined;
+    fullWidth: boolean;
+    isLoading: boolean;
+    isDisabled: boolean;
+    loadingText: string;
+    press: EventEmitter<MouseEvent>;
+    protected readonly hovered: _angular_core.WritableSignal<boolean>;
+    protected readonly pressed: _angular_core.WritableSignal<boolean>;
+    protected readonly focusVisible: _angular_core.WritableSignal<boolean>;
+    protected readonly inert: Signal<boolean>;
+    protected readonly style: Signal<_elvora_core.ButtonStyle>;
+    protected readonly rootStyle: Signal<Record<string, string | number | undefined>>;
+    protected readonly labelStyle: Signal<Record<string, string | number | undefined>>;
+    protected readonly spinnerColor: Signal<string>;
+    protected readonly spinnerSize: Signal<number>;
+    handleClick(event: MouseEvent): void;
+}
+
+/**
+ * Square icon-only button. `ariaLabel` is REQUIRED — icon-only buttons must
+ * announce a name to assistive tech.
+ */
+declare class ElvoraIconButton {
+    private readonly themeService;
+    ariaLabel: string;
+    variant: ElvoraVariant;
+    size: ElvoraSize;
+    intent: keyof ElvoraTheme['colors']['intent'] | undefined;
+    isLoading: boolean;
+    isDisabled: boolean;
+    press: EventEmitter<MouseEvent>;
+    protected readonly hovered: _angular_core.WritableSignal<boolean>;
+    protected readonly pressed: _angular_core.WritableSignal<boolean>;
+    protected readonly focusVisible: _angular_core.WritableSignal<boolean>;
+    protected readonly inert: Signal<boolean>;
+    protected readonly rootStyle: Signal<{
+        width: string;
+        minWidth: string;
+        paddingLeft: string;
+        paddingRight: string;
+    }>;
+    handleClick(event: MouseEvent): void;
+}
+
+/** Text input. Two-way binding via `[(value)]`. */
+declare class ElvoraInput {
+    private readonly themeService;
+    value: string | null;
+    type: 'text' | 'email' | 'password' | 'search' | 'tel' | 'url' | 'number';
+    placeholder?: string;
+    size: ElvoraSize;
+    status: ElvoraStatus;
+    isReadOnly: boolean;
+    isDisabled: boolean;
+    isRequired: boolean;
+    isInvalid: boolean;
+    valueChange: EventEmitter<string>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly hovered: _angular_core.WritableSignal<boolean>;
+    protected readonly style: _angular_core.Signal<Record<string, string | number | undefined>>;
+    onInput(event: Event): void;
+}
+
+/** Multi-line text input. Two-way binding via `[(value)]`. */
+declare class ElvoraTextarea {
+    private readonly themeService;
+    value: string | null;
+    placeholder?: string;
+    rows: number;
+    isResizable: boolean;
+    size: ElvoraSize;
+    status: ElvoraStatus;
+    isReadOnly: boolean;
+    isDisabled: boolean;
+    isRequired: boolean;
+    isInvalid: boolean;
+    valueChange: EventEmitter<string>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly hovered: _angular_core.WritableSignal<boolean>;
+    protected readonly combinedStyle: _angular_core.Signal<Record<string, string | number | undefined>>;
+    onInput(event: Event): void;
+}
+
+declare const sizeMap$3: {
+    sm: {
+        box: number;
+        icon: number;
+        font: number;
+    };
+    md: {
+        box: number;
+        icon: number;
+        font: number;
+    };
+    lg: {
+        box: number;
+        icon: number;
+        font: number;
+    };
+};
+type CheckboxSize = keyof typeof sizeMap$3;
+/** Checkbox. Use `[(isChecked)]` for two-way binding. */
+declare class ElvoraCheckbox {
+    private readonly themeService;
+    size: CheckboxSize;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    isChecked: boolean;
+    isIndeterminate: boolean;
+    /** Set to true when content is projected (Angular has no clean way to detect). */
+    hasLabelHint: boolean;
+    isCheckedChange: EventEmitter<boolean>;
+    get dims(): {
+        box: number;
+        icon: number;
+        font: number;
+    } | {
+        box: number;
+        icon: number;
+        font: number;
+    } | {
+        box: number;
+        icon: number;
+        font: number;
+    };
+    protected hasLabel(): boolean;
+    protected readonly fg: _angular_core.Signal<string>;
+    protected readonly boxStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        width: string;
+        height: string;
+        border: string;
+        borderRadius: string;
+        backgroundColor: string;
+        color: string;
+        transition: string;
+        cursor: string;
+        opacity: string;
+        flexShrink: string;
+    }>;
+    onToggle(event: Event): void;
+}
+
+declare const sizeMap$2: {
+    sm: {
+        outer: number;
+        inner: number;
+        font: number;
+    };
+    md: {
+        outer: number;
+        inner: number;
+        font: number;
+    };
+    lg: {
+        outer: number;
+        inner: number;
+        font: number;
+    };
+};
+type RadioSize = keyof typeof sizeMap$2;
+/**
+ * Radio group container. Provides shared name/value/size to nested
+ * `<elvora-radio>` items via DI.
+ */
+declare class ElvoraRadioGroup {
+    name: string;
+    value?: string;
+    isDisabled: boolean;
+    size: RadioSize;
+    label?: string;
+    valueChange: EventEmitter<string>;
+    readonly valueSignal: _angular_core.WritableSignal<string | undefined>;
+    ngOnChanges(): void;
+    setValue(v: string): void;
+}
+/** Single radio option. Must be a descendant of `<elvora-radio-group>`. */
+declare class ElvoraRadio {
+    private readonly themeService;
+    readonly group: ElvoraRadioGroup;
+    value: string;
+    isDisabled: boolean;
+    hasLabelHint: boolean;
+    get dims(): {
+        outer: number;
+        inner: number;
+        font: number;
+    } | {
+        outer: number;
+        inner: number;
+        font: number;
+    } | {
+        outer: number;
+        inner: number;
+        font: number;
+    };
+    protected isChecked(): boolean;
+    protected disabled(): boolean;
+    protected readonly fg: _angular_core.Signal<string>;
+    protected readonly outerStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        width: string;
+        height: string;
+        border: string;
+        borderRadius: string;
+        backgroundColor: string;
+        transition: string;
+        flexShrink: string;
+    }>;
+    protected readonly innerStyle: _angular_core.Signal<{
+        width: string;
+        height: string;
+        borderRadius: string;
+        backgroundColor: string;
+        transform: string;
+        transition: string;
+    }>;
+    onChange(): void;
+}
+
+declare const sizeMap$1: {
+    sm: {
+        trackW: number;
+        trackH: number;
+        thumb: number;
+    };
+    md: {
+        trackW: number;
+        trackH: number;
+        thumb: number;
+    };
+    lg: {
+        trackW: number;
+        trackH: number;
+        thumb: number;
+    };
+};
+type SwitchSize = keyof typeof sizeMap$1;
+/** Toggle switch. Use `[(isChecked)]` for two-way binding. */
+declare class ElvoraSwitch {
+    private readonly themeService;
+    size: SwitchSize;
+    isDisabled: boolean;
+    isChecked: boolean;
+    hasLabelHint: boolean;
+    isCheckedChange: EventEmitter<boolean>;
+    protected readonly fg: _angular_core.Signal<string>;
+    protected readonly trackStyle: _angular_core.Signal<{
+        position: string;
+        display: string;
+        width: string;
+        height: string;
+        backgroundColor: string;
+        border: string;
+        borderRadius: string;
+        transition: string;
+        cursor: string;
+        opacity: string;
+        flexShrink: string;
+    }>;
+    protected readonly thumbStyle: _angular_core.Signal<{
+        position: string;
+        top: string;
+        left: string;
+        transform: string;
+        width: string;
+        height: string;
+        backgroundColor: string;
+        borderRadius: string;
+        boxShadow: string;
+        transition: string;
+    }>;
+    onToggle(event: Event): void;
+}
+
+interface ElvoraSelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+/** Native `<select>` styled with Elvora tokens. */
+declare class ElvoraSelect {
+    private readonly themeService;
+    options: ElvoraSelectOption[];
+    value: string | null;
+    placeholder?: string;
+    size: ElvoraSize;
+    status: ElvoraStatus;
+    isDisabled: boolean;
+    isRequired: boolean;
+    isInvalid: boolean;
+    valueChange: EventEmitter<string>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly hovered: _angular_core.WritableSignal<boolean>;
+    protected readonly style: _angular_core.Signal<{
+        appearance: string;
+        paddingRight: number;
+    }>;
+    protected readonly chevronStyle: _angular_core.Signal<{
+        position: string;
+        right: string;
+        top: string;
+        transform: string;
+        color: string;
+        pointerEvents: string;
+        display: string;
+    }>;
+    onChange(event: Event): void;
+}
+
+declare const sizeMap: {
+    xs: {
+        fontSize: number;
+        gap: number;
+    };
+    sm: {
+        fontSize: number;
+        gap: number;
+    };
+    md: {
+        fontSize: number;
+        gap: number;
+    };
+    lg: {
+        fontSize: number;
+        gap: number;
+    };
+};
+type LabelSize = keyof typeof sizeMap;
+/** Form label. Use `for` attribute to associate with a form control. */
+declare class ElvoraLabel {
+    private readonly themeService;
+    for?: string;
+    isRequired: boolean;
+    size: LabelSize;
+    protected readonly rootStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        gap: string;
+        color: string;
+        fontFamily: "\"Inter\", \"Segoe UI\", -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, sans-serif";
+        fontSize: string;
+        fontWeight: string;
+        lineHeight: string;
+        userSelect: string;
+    }>;
+    protected readonly dangerFg: _angular_core.Signal<string>;
+}
+
+/** Renders an SVG icon from `@elvora/icons` by name. */
+declare class ElvoraIcon {
+    name: IconName;
+    size: number;
+    color: string;
+    label?: string;
+    def(): _elvora_icons.IconDef | null;
+}
+
+/**
+ * Visual separator. Set `withLabel` to true and project content for an
+ * "OR"-style inline divider.
+ */
+declare class ElvoraDivider {
+    private readonly themeService;
+    orientation: Orientation;
+    thickness: number;
+    withLabel: boolean;
+    isDecorative?: boolean;
+    get role(): "presentation" | "separator";
+    protected readonly wrapperStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        gap: string;
+        color: string;
+        fontSize: string;
+    }>;
+    protected readonly lineFlex: _angular_core.Signal<{
+        flex: string;
+        borderTop: string;
+    }>;
+    protected readonly lineStyle: _angular_core.Signal<{
+        width: string;
+        alignSelf: string;
+        backgroundColor: string;
+        height?: undefined;
+    } | {
+        height: string;
+        width: string;
+        backgroundColor: string;
+        alignSelf?: undefined;
+    }>;
+}
+
+/** User avatar. Falls back gracefully: image → initials → custom fallback. */
+declare class ElvoraAvatar {
+    private readonly themeService;
+    private readonly imgFailed;
+    src?: string;
+    alt?: string;
+    name?: string;
+    size: ElvoraSize;
+    shape: 'circle' | 'square';
+    get initials(): string;
+    protected showImage(): boolean;
+    protected onImgError(): void;
+    protected readonly containerStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        width: string;
+        height: string;
+        flexShrink: string;
+        overflow: string;
+        borderRadius: string;
+        backgroundColor: string;
+        color: string;
+        fontFamily: "\"Inter\", \"Segoe UI\", -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, sans-serif";
+        fontSize: string;
+        fontWeight: string;
+        userSelect: string;
+    }>;
+}
+
+type BadgeSize = Exclude<ElvoraSize, 'xl'>;
+/** Small status indicator (e.g. notification count, status pip). */
+declare class ElvoraBadge {
+    private readonly themeService;
+    status: ElvoraStatus;
+    size: BadgeSize;
+    tone: ElvoraTone;
+    isDot: boolean;
+    private resolveColors;
+    protected readonly dotStyle: _angular_core.Signal<{
+        display: string;
+        width: string;
+        height: string;
+        backgroundColor: string;
+        borderRadius: string;
+        border: string;
+    }>;
+    protected readonly badgeStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        paddingLeft: string;
+        paddingRight: string;
+        paddingTop: string;
+        paddingBottom: string;
+        minHeight: string;
+        borderRadius: string;
+        borderWidth: string;
+        borderStyle: string;
+        borderColor: string;
+        backgroundColor: string;
+        color: string;
+        fontFamily: "\"Inter\", \"Segoe UI\", -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, sans-serif";
+        fontSize: string;
+        fontWeight: string;
+        lineHeight: string;
+        whiteSpace: string;
+    }>;
+}
+
+type TagSize = Exclude<ElvoraSize, 'xl'>;
+/** Tag — a labeled chip. Optionally dismissible via `(close)`. */
+declare class ElvoraTag {
+    private readonly themeService;
+    status: ElvoraStatus;
+    size: TagSize;
+    tone: ElvoraTone;
+    dismissible: boolean;
+    closeLabel: string;
+    close: EventEmitter<MouseEvent>;
+    get dims(): {
+        padX: number;
+        padY: number;
+        font: number;
+        height: number;
+    } | {
+        padX: number;
+        padY: number;
+        font: number;
+        height: number;
+    } | {
+        padX: number;
+        padY: number;
+        font: number;
+        height: number;
+    } | {
+        padX: number;
+        padY: number;
+        font: number;
+        height: number;
+    };
+    private resolveColors;
+    protected readonly rootColor: _angular_core.Signal<string>;
+    protected readonly rootStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        gap: string;
+        paddingLeft: string;
+        paddingRight: string;
+        paddingTop: string;
+        paddingBottom: string;
+        minHeight: string;
+        borderRadius: string;
+        borderWidth: string;
+        borderStyle: string;
+        borderColor: string;
+        backgroundColor: string;
+        color: string;
+        fontFamily: "\"Inter\", \"Segoe UI\", -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, sans-serif";
+        fontSize: string;
+        fontWeight: string;
+        lineHeight: string;
+        whiteSpace: string;
+    }>;
+    protected readonly closeBtnStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        width: string;
+        height: string;
+        border: string;
+        background: string;
+        color: string;
+        cursor: string;
+        borderRadius: string;
+        padding: string;
+        marginLeft: string;
+    }>;
+}
+
+/** Spinner — accessible loading indicator. */
+declare class ElvoraSpinner {
+    size: ElvoraSize | number;
+    color: string;
+    label: string;
+    thickness: number;
+    get px(): number;
+}
+
+type ProgressSize = Exclude<ElvoraSize, 'xl'>;
+/** Linear progress bar. Omit `value` for indeterminate. */
+declare class ElvoraProgress {
+    private readonly themeService;
+    value?: number;
+    max: number;
+    min: number;
+    size: ProgressSize;
+    status: ElvoraStatus;
+    label?: string;
+    get indeterminate(): boolean;
+    get clamped(): number;
+    get pct(): number;
+    protected readonly trackStyle: _angular_core.Signal<{
+        position: string;
+        width: string;
+        height: string;
+        backgroundColor: string;
+        borderRadius: string;
+        overflow: string;
+    }>;
+    protected readonly fillStyle: _angular_core.Signal<{
+        position: string;
+        inset: string;
+        width: string;
+        backgroundColor: string;
+        borderRadius: string;
+        transition: string;
+        animation: string;
+    }>;
+}
+
+/**
+ * Tooltip directive. Apply to any focusable element; shows `label` on hover/
+ * focus. Adds `aria-describedby` for assistive tech. For richer positioning,
+ * compose with a popover library in Phase 2.
+ *
+ * ```html
+ * <button elvoraTooltip="Save changes">💾</button>
+ * ```
+ */
+declare class ElvoraTooltip implements OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    private readonly themeService;
+    label: string;
+    placement: Placement;
+    openDelay: number;
+    closeDelay: number;
+    private readonly id;
+    private tip;
+    private timer;
+    onEnter(): void;
+    onLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    private scheduleShow;
+    private scheduleHide;
+    private show;
+    private applyPlacement;
+    private hide;
+    ngOnDestroy(): void;
+}
+
+/** Box — universal layout primitive. Accepts shorthand style inputs. */
+declare class ElvoraBox {
+    p?: number | string;
+    px?: number | string;
+    py?: number | string;
+    pt?: number | string;
+    pr?: number | string;
+    pb?: number | string;
+    pl?: number | string;
+    m?: number | string;
+    mx?: number | string;
+    my?: number | string;
+    mt?: number | string;
+    mr?: number | string;
+    mb?: number | string;
+    ml?: number | string;
+    w?: number | string;
+    h?: number | string;
+    bg?: string;
+    color?: string;
+    rounded?: number | string;
+    shadow?: string;
+    get resolvedStyle(): Record<string, string | number>;
+}
+
+type Direction = 'row' | 'column' | 'row-reverse' | 'column-reverse';
+/** Stack — flex container with `gap`, `direction`, `align`, `justify`. */
+declare class ElvoraStack {
+    direction: Direction;
+    gap: number | string;
+    align?: string;
+    justify?: string;
+    wrap: boolean;
+    inline: boolean;
+    get resolvedStyle(): Record<string, string | number>;
+}
+/** HStack — horizontal Stack convenience component. */
+declare class ElvoraHStack {
+    gap: number | string;
+    align?: string;
+    justify?: string;
+}
+/** VStack — vertical Stack convenience component. */
+declare class ElvoraVStack {
+    gap: number | string;
+    align?: string;
+    justify?: string;
+}
+
+/** Grid — CSS Grid container. */
+declare class ElvoraGrid {
+    columns: number | string;
+    gap: number | string;
+    rows?: number | string;
+    autoFlow?: string;
+    get resolvedStyle(): Record<string, string | number>;
+}
+/** GridItem — child of `<elvora-grid>` with span controls. */
+declare class ElvoraGridItem {
+    colSpan?: number;
+    rowSpan?: number;
+    colStart?: number;
+    colEnd?: number;
+    get resolvedStyle(): Record<string, string | number>;
+}
+
+/** Container — centered, max-width container. */
+declare class ElvoraContainer {
+    size: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+    padding: number | string;
+    centerContent: boolean;
+    get resolvedStyle(): Record<string, string | number>;
+}
+
+/** Card — content container with elevation, padding, rounded corners. */
+declare class ElvoraCard {
+    private readonly themeService;
+    variant: 'outline' | 'elevated' | 'filled';
+    padding: number | string;
+    protected readonly cardStyle: _angular_core.Signal<{
+        backgroundColor: string;
+        border: string;
+        boxShadow: string;
+        borderRadius: string;
+        padding: string;
+    }>;
+}
+declare class ElvoraCardHeader {
+    private readonly themeService;
+    protected readonly style: _angular_core.Signal<{
+        paddingBottom: string;
+        borderBottom: string;
+        marginBottom: string;
+    }>;
+}
+declare class ElvoraCardBody {
+}
+declare class ElvoraCardFooter {
+    private readonly themeService;
+    protected readonly style: _angular_core.Signal<{
+        paddingTop: string;
+        borderTop: string;
+        marginTop: string;
+    }>;
+}
+
+/** Alert — banner-style feedback message. */
+declare class ElvoraAlert {
+    private readonly themeService;
+    status: ElvoraStatus;
+    tone: ElvoraTone;
+    title?: string;
+    description?: string;
+    closeable: boolean;
+    closeLabel: string;
+    readonly close: EventEmitter<void>;
+    protected iconName(): IconName;
+    protected roleAttr(): "alert" | "status";
+    protected readonly rootStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        gap: string;
+        padding: string;
+        borderRadius: string;
+        backgroundColor: string;
+        color: string;
+        borderWidth: string;
+        borderStyle: string;
+        borderColor: string;
+    }>;
+    protected readonly titleStyle: _angular_core.Signal<{
+        fontWeight: string;
+        fontSize: string;
+        marginBottom: string;
+    }>;
+}
+
+/** Skeleton — placeholder block with optional pulsing animation. */
+declare class ElvoraSkeleton {
+    private readonly themeService;
+    width: number | string;
+    height: number | string;
+    rounded?: number | string;
+    animated: boolean;
+    protected readonly boxStyle: _angular_core.Signal<{
+        width: string;
+        height: string;
+        borderRadius: string;
+        backgroundColor: string;
+        animation: string;
+    }>;
+}
+
+/** Empty — placeholder for no-data states. */
+declare class ElvoraEmpty {
+    private readonly themeService;
+    title: string;
+    description?: string;
+    protected fgSubtle(): string;
+    protected readonly wrapperStyle: _angular_core.Signal<{
+        display: string;
+        flexDirection: string;
+        alignItems: string;
+        gap: string;
+        padding: string;
+        textAlign: string;
+    }>;
+    protected readonly iconStyle: _angular_core.Signal<{
+        color: string;
+    }>;
+    protected readonly titleStyle: _angular_core.Signal<{
+        color: string;
+        fontWeight: string;
+        fontSize: string;
+    }>;
+    protected readonly descStyle: _angular_core.Signal<{
+        color: string;
+        fontSize: string;
+    }>;
+}
+
+type ElvoraResultStatus = ElvoraStatus | '404' | '500' | '403';
+/** Result — page-level status component. */
+declare class ElvoraResult {
+    private readonly themeService;
+    status: ElvoraResultStatus;
+    title?: string;
+    subtitle?: string;
+    hasExtra: boolean;
+    protected iconName(): IconName;
+    protected iconColor(): string;
+    protected readonly wrapperStyle: _angular_core.Signal<{
+        display: string;
+        flexDirection: string;
+        alignItems: string;
+        gap: string;
+        padding: string;
+        textAlign: string;
+    }>;
+    protected readonly iconWrapStyle: _angular_core.Signal<{
+        color: string;
+    }>;
+    protected readonly titleStyle: _angular_core.Signal<{
+        color: string;
+        fontWeight: string;
+        fontSize: string;
+    }>;
+    protected readonly subtitleStyle: _angular_core.Signal<{
+        color: string;
+        fontSize: string;
+    }>;
+}
+
+/** Modal — centered overlay dialog. Renders inline (no portal). */
+declare class ElvoraModal {
+    private readonly themeService;
+    isOpen: boolean;
+    size: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    title?: string;
+    showCloseButton: boolean;
+    closeOnEscape: boolean;
+    closeOnOverlayClick: boolean;
+    hasFooter: boolean;
+    closeLabel: string;
+    close: EventEmitter<void>;
+    constructor();
+    onEscape(): void;
+    onOverlayClick(_e: MouseEvent): void;
+    protected readonly overlayStyle: _angular_core.Signal<{
+        position: string;
+        inset: string;
+        backgroundColor: string;
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        padding: string;
+        zIndex: string;
+    }>;
+    protected readonly dialogStyle: _angular_core.Signal<{
+        backgroundColor: string;
+        color: string;
+        borderRadius: string;
+        boxShadow: "0 20px 25px -5px rgba(15, 23, 42, 0.10), 0 8px 10px -6px rgba(15, 23, 42, 0.10)";
+        width: string;
+        maxWidth: "380px" | "520px" | "720px" | "960px" | "95vw";
+        maxHeight: string;
+        display: string;
+        flexDirection: string;
+        overflow: string;
+    }>;
+    protected readonly headerStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        gap: string;
+        padding: string;
+        borderBottom: string;
+    }>;
+    protected readonly footerStyle: _angular_core.Signal<{
+        display: string;
+        gap: string;
+        justifyContent: string;
+        padding: string;
+        borderTop: string;
+    }>;
+}
+
+/** Drawer — edge-anchored overlay panel. */
+declare class ElvoraDrawer {
+    private readonly themeService;
+    isOpen: boolean;
+    placement: 'left' | 'right' | 'top' | 'bottom';
+    size: number | string;
+    title?: string;
+    showCloseButton: boolean;
+    closeOnEscape: boolean;
+    closeOnOverlayClick: boolean;
+    hasFooter: boolean;
+    closeLabel: string;
+    close: EventEmitter<void>;
+    constructor();
+    onEscape(): void;
+    onOverlayClick(): void;
+    protected readonly overlayStyle: _angular_core.Signal<{
+        position: string;
+        inset: string;
+        backgroundColor: string;
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        zIndex: string;
+    }>;
+    protected readonly panelStyle: _angular_core.Signal<{
+        backgroundColor: string;
+        color: string;
+        boxShadow: "0 20px 25px -5px rgba(15, 23, 42, 0.10), 0 8px 10px -6px rgba(15, 23, 42, 0.10)";
+        display: string;
+        flexDirection: string;
+        width: string;
+        height: string;
+        maxWidth: string;
+        maxHeight: string;
+        overflow: string;
+    }>;
+    protected readonly headerStyle: _angular_core.Signal<{
+        display: string;
+        alignItems: string;
+        gap: string;
+        padding: string;
+        borderBottom: string;
+    }>;
+    protected readonly footerStyle: _angular_core.Signal<{
+        display: string;
+        gap: string;
+        justifyContent: string;
+        padding: string;
+        borderTop: string;
+    }>;
+}
+
+/**
+ * Popover — content overlay anchored to a host element. Project the trigger
+ * inside `<elvora-popover>` and the panel content into the `[slot=content]`
+ * projection slot.
+ */
+declare class ElvoraPopover {
+    private readonly themeService;
+    private readonly host;
+    isOpen: boolean;
+    placement: 'top' | 'bottom' | 'left' | 'right';
+    openChange: EventEmitter<boolean>;
+    toggle(event: MouseEvent): void;
+    onDocClick(event: MouseEvent): void;
+    onEsc(): void;
+    protected readonly panelStyle: _angular_core.Signal<Record<string, string>>;
+}
+
+interface ElvoraToastOptions {
+    id?: string;
+    status?: ElvoraStatus;
+    title?: string;
+    description?: string;
+    /** Duration in ms. `null` for sticky. */
+    duration?: number | null;
+}
+interface ToastInstance {
+    id: string;
+    status: ElvoraStatus;
+    title?: string;
+    description?: string;
+    duration: number | null;
+}
+/**
+ * Global toast service. Inject anywhere and call `show()`. Mount
+ * `<elvora-toast-host></elvora-toast-host>` once at the application root.
+ */
+declare class ElvoraToastService {
+    private readonly toastsSignal;
+    readonly toasts: _angular_core.Signal<ToastInstance[]>;
+    defaultDuration: number;
+    show(opts: ElvoraToastOptions): string;
+    dismiss(id: string): void;
+    dismissAll(): void;
+}
+/**
+ * Toast viewport. Mount once near the application root.
+ *
+ * ```html
+ * <elvora-toast-host placement="top-right"></elvora-toast-host>
+ * ```
+ */
+declare class ElvoraToastHost {
+    private readonly themeService;
+    private readonly service;
+    toasts: _angular_core.Signal<ToastInstance[]>;
+    /** Position the stack appears in. */
+    placement: 'top-right' | 'top-left' | 'top-center' | 'bottom-right' | 'bottom-left' | 'bottom-center';
+    protected readonly containerStyle: _angular_core.Signal<Record<string, string>>;
+    trackById(_idx: number, item: ToastInstance): string;
+    dismiss(id: string): void;
+}
+
+/** Tab definition. Use as a child of `<elvora-tabs>`. */
+declare class ElvoraTabTemplate {
+    value: string;
+    label: string;
+    isDisabled: boolean;
+    readonly template: TemplateRef<unknown>;
+}
+type Variant = 'underline' | 'pill' | 'solid';
+/**
+ * Tabs — WAI-ARIA Tabs pattern with keyboard navigation. Use with
+ * `<elvora-tab-template>` children which carry a `value`, `label`, and panel
+ * template content.
+ */
+declare class ElvoraTabs implements AfterContentInit {
+    private readonly themeService;
+    private static counter;
+    protected readonly baseId: string;
+    value: string;
+    variant: Variant;
+    orientation: Orientation;
+    activation: 'automatic' | 'manual';
+    valueChange: EventEmitter<string>;
+    private tabRefs?;
+    protected readonly templatesSignal: _angular_core.WritableSignal<ElvoraTabTemplate[]>;
+    protected get templates(): ElvoraTabTemplate[];
+    constructor();
+    ngAfterContentInit(): void;
+    protected onClick(value: string, disabled: boolean): void;
+    protected onKey(event: KeyboardEvent, index: number): void;
+    protected readonly listStyle: _angular_core.Signal<{
+        display: string;
+        flexDirection: string;
+        gap: string;
+        borderBottom: string;
+    }>;
+    protected tabStyle(active: boolean, disabled?: boolean): Record<string, string>;
+}
+
+interface ElvoraMenuItem {
+    value: string;
+    label: string;
+    isDisabled?: boolean;
+    hasSeparatorBefore?: boolean;
+}
+/**
+ * Dropdown menu. Project the trigger as the default slot. Items are passed as
+ * an input.
+ */
+declare class ElvoraMenu {
+    private readonly themeService;
+    private readonly host;
+    items: ElvoraMenuItem[];
+    placement: 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+    select: EventEmitter<string>;
+    isOpen: boolean;
+    toggle(): void;
+    onSelect(item: ElvoraMenuItem): void;
+    onDocClick(event: MouseEvent): void;
+    onEsc(): void;
+    protected readonly listStyle: _angular_core.Signal<Record<string, string>>;
+    protected itemStyle(disabled?: boolean): Record<string, string>;
+    protected readonly separatorStyle: _angular_core.Signal<{
+        height: string;
+        margin: string;
+        backgroundColor: string;
+    }>;
+}
+
+interface ElvoraBreadcrumbItem {
+    label: string;
+    href?: string;
+    isCurrent?: boolean;
+}
+/** Breadcrumb — navigation trail. */
+declare class ElvoraBreadcrumb {
+    private readonly themeService;
+    items: ElvoraBreadcrumbItem[];
+    activate: EventEmitter<number>;
+    emit(i: number, e: MouseEvent): void;
+    protected readonly listStyle: _angular_core.Signal<{
+        listStyle: string;
+        margin: string;
+        padding: string;
+        display: string;
+        alignItems: string;
+        flexWrap: string;
+        gap: string;
+        fontSize: string;
+    }>;
+    protected linkStyle(current: boolean): {
+        color: string;
+        textDecoration: string;
+    };
+    protected separatorColor(): string;
+}
+
+/** Pagination — accessible page navigator. */
+declare class ElvoraPagination {
+    private readonly themeService;
+    total: number;
+    pageSize: number;
+    current: number;
+    siblingCount: number;
+    showFirstLast: boolean;
+    hideOnSinglePage: boolean;
+    currentChange: EventEmitter<number>;
+    get totalPages(): number;
+    get visible(): boolean;
+    get pages(): (number | "gap")[];
+    numberOf(p: number | 'gap'): number;
+    go(next: number): void;
+    protected btnStyle(active: boolean, disabled?: boolean): {
+        appearance: string;
+        minWidth: string;
+        height: string;
+        padding: string;
+        borderRadius: string;
+        border: string;
+        backgroundColor: string;
+        color: string;
+        cursor: string;
+        opacity: string;
+        fontSize: string;
+        fontWeight: string;
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+    };
+    protected gapStyle: _angular_core.Signal<{
+        padding: string;
+        color: string;
+    }>;
+}
+
+interface ElvoraStep {
+    title: string;
+    description?: string;
+    status?: 'wait' | 'process' | 'finish' | 'error';
+}
+/** Steps — multi-step progress indicator. */
+declare class ElvoraSteps {
+    private readonly themeService;
+    steps: ElvoraStep[];
+    current: number;
+    orientation: 'horizontal' | 'vertical';
+    change: EventEmitter<number>;
+    get clickable(): boolean;
+    resolveStatus(i: number, override?: ElvoraStep['status']): 'wait' | 'process' | 'finish' | 'error';
+    onClick(i: number): void;
+    protected readonly listStyle: _angular_core.Signal<{
+        listStyle: string;
+        margin: string;
+        padding: string;
+        display: string;
+        flexDirection: string;
+        gap: string;
+        alignItems: string;
+    }>;
+    protected readonly itemStyle: _angular_core.Signal<{
+        display: string;
+        flex: string;
+        flexDirection: string;
+        alignItems: string;
+        gap: string;
+    }>;
+    protected dotStyle(status: 'wait' | 'process' | 'finish' | 'error'): Record<string, string>;
+    protected readonly textWrapStyle: _angular_core.Signal<{
+        textAlign: string;
+    }>;
+    protected titleStyle(status: 'wait' | 'process' | 'finish' | 'error'): {
+        fontSize: string;
+        fontWeight: string;
+        color: string;
+    };
+    protected readonly descStyle: _angular_core.Signal<{
+        fontSize: string;
+        color: string;
+        marginTop: string;
+    }>;
+    protected connectorStyle(status: 'wait' | 'process' | 'finish' | 'error'): {
+        flex: string;
+        height: string;
+        backgroundColor: string;
+        alignSelf: string;
+        marginTop: string;
+        width?: undefined;
+        minHeight?: undefined;
+        marginLeft?: undefined;
+    } | {
+        width: string;
+        minHeight: string;
+        backgroundColor: string;
+        marginLeft: string;
+        flex?: undefined;
+        height?: undefined;
+        alignSelf?: undefined;
+        marginTop?: undefined;
+    };
+}
+
+interface ElvoraAnchorLink {
+    href: string;
+    label: string;
+    children?: ElvoraAnchorLink[];
+}
+/** Anchor — in-page navigation. */
+declare class ElvoraAnchor {
+    private readonly themeService;
+    protected readonly activeHref: _angular_core.WritableSignal<string | null>;
+    links: ElvoraAnchorLink[];
+    offsetTop: number;
+    smooth: boolean;
+    onScroll(): void;
+    onActivate(event: MouseEvent, href: string): void;
+    protected linkStyle(href: string, depth: number): {
+        display: string;
+        padding: string;
+        paddingLeft: string;
+        color: string;
+        fontSize: string;
+        textDecoration: string;
+        borderLeft: string;
+        backgroundColor: string;
+    };
+}
+
+/** BackTop — floating "scroll to top" button. */
+declare class ElvoraBackTop {
+    private readonly themeService;
+    protected readonly visible: _angular_core.WritableSignal<boolean>;
+    visibilityHeight: number;
+    bottom: number;
+    right: number;
+    smooth: boolean;
+    label: string;
+    onScroll(): void;
+    onClick(): void;
+    protected readonly btnStyle: _angular_core.Signal<{
+        position: string;
+        bottom: string;
+        right: string;
+        width: string;
+        height: string;
+        borderRadius: string;
+        border: string;
+        backgroundColor: string;
+        color: string;
+        boxShadow: string;
+        cursor: string;
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        zIndex: string;
+    }>;
+}
+
+declare class ElvoraFormState {
+    layout: _angular_core.WritableSignal<"vertical" | "horizontal">;
+    labelWidth: _angular_core.WritableSignal<string | number | null>;
+    errors: _angular_core.WritableSignal<Record<string, string | undefined>>;
+    setLayout(value: 'vertical' | 'horizontal'): void;
+    setLabelWidth(value: number | string | null): void;
+    setFieldError(name: string, error: string | undefined): void;
+    errorFor(name: string): string | undefined;
+}
+declare class ElvoraForm {
+    private readonly state;
+    set layout(value: 'vertical' | 'horizontal');
+    get layout(): "vertical" | "horizontal";
+    set labelWidth(value: number | string | null);
+    get labelWidth(): number | string | null;
+    readonly onSubmit: EventEmitter<Event>;
+}
+declare class ElvoraFormField {
+    private readonly themeService;
+    private readonly state;
+    name: string;
+    label?: string;
+    hint?: string;
+    error?: string;
+    isRequired: boolean;
+    readonly displayedError: _angular_core.Signal<string | undefined>;
+    protected readonly wrapperStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly labelStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly hintStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly errorStyle: _angular_core.Signal<Record<string, string>>;
+}
+
+declare class ElvoraNumberInput {
+    private readonly themeService;
+    value: number | null;
+    min?: number;
+    max?: number;
+    step: number;
+    precision?: number;
+    isDisabled: boolean;
+    isReadOnly: boolean;
+    isInvalid: boolean;
+    hideSteppers: boolean;
+    placeholder?: string;
+    readonly valueChange: EventEmitter<number | null>;
+    protected text: string;
+    private setValue;
+    protected increment(delta: number): void;
+    protected onInput(e: Event): void;
+    protected onBlur(): void;
+    protected onKeyDown(e: KeyboardEvent): void;
+    protected readonly wrapperStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly inputStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly stepperContainerStyle: _angular_core.Signal<Record<string, string>>;
+    protected stepperBtnStyle(top: boolean): Record<string, string>;
+}
+
+interface ElvoraSegmentedOption {
+    value: string;
+    label: string;
+    isDisabled?: boolean;
+}
+declare class ElvoraSegmented {
+    private readonly themeService;
+    options: ElvoraSegmentedOption[];
+    value: string;
+    size: 'sm' | 'md' | 'lg';
+    isDisabled: boolean;
+    readonly valueChange: EventEmitter<string>;
+    protected select(opt: ElvoraSegmentedOption): void;
+    protected readonly containerStyle: _angular_core.Signal<Record<string, string>>;
+    protected btnStyle(active: boolean): Record<string, string>;
+}
+
+declare class ElvoraSlider {
+    private readonly themeService;
+    private trackRef?;
+    value: number;
+    min: number;
+    max: number;
+    step: number;
+    isDisabled: boolean;
+    readonly valueChange: EventEmitter<number>;
+    readonly valueChangeEnd: EventEmitter<number>;
+    private dragging;
+    private commit;
+    private valueFromClient;
+    protected onPointerDown(e: PointerEvent): void;
+    protected onPointerMove(e: PointerEvent): void;
+    protected onPointerUp(e: PointerEvent): void;
+    protected onGlobalUp(): void;
+    protected onKeyDown(e: KeyboardEvent): void;
+    protected readonly wrapperStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly trackStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly fillStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly thumbStyle: _angular_core.Signal<Record<string, string>>;
+}
+
+declare class ElvoraRate {
+    private readonly themeService;
+    value: number;
+    count: number;
+    allowHalf: boolean;
+    isDisabled: boolean;
+    ariaLabel: string;
+    readonly valueChange: EventEmitter<number>;
+    protected readonly hover: _angular_core.WritableSignal<number | null>;
+    protected get slots(): unknown[];
+    protected setValue(next: number): void;
+    protected onHover(e: MouseEvent, i: number): void;
+    protected onPick(e: MouseEvent, i: number): void;
+    protected onKey(e: KeyboardEvent): void;
+    protected readonly containerStyle: _angular_core.Signal<Record<string, string>>;
+    protected starStyle(i: number): Record<string, string>;
+}
+
+interface ElvoraUploadFile {
+    id: string;
+    file: File;
+    status: 'pending' | 'uploading' | 'done' | 'error';
+    progress?: number;
+    error?: string;
+}
+declare class ElvoraUpload {
+    private readonly themeService;
+    files: ElvoraUploadFile[];
+    multiple: boolean;
+    accept?: string;
+    description?: string;
+    isDisabled: boolean;
+    readonly filesChange: EventEmitter<ElvoraUploadFile[]>;
+    readonly upload: EventEmitter<File[]>;
+    protected readonly dragOver: _angular_core.WritableSignal<boolean>;
+    protected onInput(e: Event): void;
+    protected onDragOver(e: DragEvent): void;
+    protected onDrop(e: DragEvent): void;
+    private handleFiles;
+    protected remove(id: string): void;
+    protected readonly dropzoneStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly hintStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly rowStyle: _angular_core.Signal<Record<string, string>>;
+}
+
+interface ElvoraAutoCompleteOption {
+    value: string;
+    label?: string;
+}
+declare class ElvoraAutoComplete {
+    private readonly themeService;
+    private readonly host;
+    value: string;
+    options: ElvoraAutoCompleteOption[];
+    placeholder?: string;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    readonly valueChange: EventEmitter<string>;
+    readonly selected: EventEmitter<ElvoraAutoCompleteOption>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly highlight: _angular_core.WritableSignal<number>;
+    protected readonly filtered: _angular_core.Signal<ElvoraAutoCompleteOption[]>;
+    protected onInput(e: Event): void;
+    protected open(): void;
+    protected select(opt: ElvoraAutoCompleteOption): void;
+    protected onKeyDown(e: KeyboardEvent): void;
+    protected onDocMouse(e: MouseEvent): void;
+    protected readonly inputStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly listStyle: _angular_core.Signal<Record<string, string>>;
+    protected itemStyle(active: boolean): Record<string, string>;
+}
+
+declare class ElvoraColorPicker {
+    private readonly themeService;
+    private readonly host;
+    set value(v: string);
+    get value(): string;
+    private _value;
+    presets: string[];
+    isDisabled: boolean;
+    readonly valueChange: EventEmitter<string>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly hexInput: _angular_core.WritableSignal<string>;
+    protected readonly currentValue: _angular_core.Signal<string>;
+    protected toggle(): void;
+    protected set(next: string): void;
+    protected onPick(e: Event): void;
+    protected onHexInput(e: Event): void;
+    protected onDocMouse(e: MouseEvent): void;
+    protected readonly triggerStyle: _angular_core.Signal<Record<string, string>>;
+    protected swatchStyle(color: string, button?: boolean): Record<string, string>;
+    protected readonly popoverStyle: _angular_core.Signal<Record<string, string>>;
+}
+
+declare class ElvoraDatePicker {
+    private readonly themeService;
+    private readonly host;
+    value: Date | null;
+    min?: Date;
+    max?: Date;
+    placeholder?: string;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    format: (d: Date) => string;
+    readonly valueChange: EventEmitter<Date | null>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly view: _angular_core.WritableSignal<Date>;
+    protected get weekdays(): string[];
+    protected toggle(): void;
+    protected prev(): void;
+    protected next(): void;
+    protected pick(d: Date): void;
+    protected isInRange(d: Date): boolean;
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    protected readonly flatMatrix: _angular_core.Signal<Date[]>;
+    protected onDocMouse(e: MouseEvent): void;
+    protected readonly triggerStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly popoverStyle: _angular_core.Signal<Record<string, string>>;
+    protected dayStyle(d: Date): Record<string, string>;
+}
+
+interface ElvoraTimeValue {
+    hours: number;
+    minutes: number;
+    seconds?: number;
+}
+declare class ElvoraTimePicker {
+    private readonly themeService;
+    private readonly host;
+    value: ElvoraTimeValue | null;
+    showSeconds: boolean;
+    use12Hours: boolean;
+    minuteStep: number;
+    placeholder?: string;
+    isDisabled: boolean;
+    readonly valueChange: EventEmitter<ElvoraTimeValue | null>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly pad: (n: number) => string;
+    protected get hours(): number[];
+    protected get minutes(): number[];
+    protected get seconds(): number[];
+    protected get activeHour(): number | undefined;
+    protected display(h: number): string;
+    protected formatted: _angular_core.Signal<string>;
+    protected setHour(h: number): void;
+    protected setMinute(m: number): void;
+    protected setSecond(s: number): void;
+    protected setPeriod(p: string): void;
+    protected periodStyle(p: string): Record<string, string>;
+    private emit;
+    protected onDocMouse(e: MouseEvent): void;
+    protected readonly triggerStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly popoverStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly colStyle: _angular_core.Signal<Record<string, string>>;
+    protected cellStyle(active: boolean): Record<string, string>;
+}
+
+interface ElvoraDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+declare class ElvoraDateRangePicker {
+    private readonly themeService;
+    private readonly host;
+    value: ElvoraDateRange | null;
+    min?: Date;
+    max?: Date;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    format: (d: Date) => string;
+    placeholder?: {
+        start?: string;
+        end?: string;
+    };
+    readonly valueChange: EventEmitter<ElvoraDateRange>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly view: _angular_core.WritableSignal<Date>;
+    private pendingStart;
+    protected toggle(): void;
+    protected prev(): void;
+    protected next(): void;
+    protected pickDay(d: Date): void;
+    protected isInRange(d: Date): boolean;
+    protected get weekdays(): string[];
+    protected monthLabel(offset: number): string;
+    protected flatMatrix(offset: number): Date[];
+    protected onDocMouse(e: MouseEvent): void;
+    protected readonly triggerStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly popoverStyle: _angular_core.Signal<Record<string, string>>;
+    protected dayStyle(d: Date, offset: number): Record<string, string>;
+}
+
+interface ElvoraCascaderOption {
+    value: string;
+    label: string;
+    children?: ElvoraCascaderOption[];
+    isDisabled?: boolean;
+}
+declare class ElvoraCascader {
+    private readonly themeService;
+    private readonly host;
+    options: ElvoraCascaderOption[];
+    value: string[];
+    placeholder?: string;
+    displaySeparator: string;
+    isDisabled: boolean;
+    readonly valueChange: EventEmitter<{
+        value: string[];
+        path: ElvoraCascaderOption[];
+    }>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    private activePath;
+    protected readonly columns: _angular_core.Signal<ElvoraCascaderOption[][]>;
+    protected readonly displayed: _angular_core.Signal<string>;
+    protected toggle(): void;
+    protected onSelectAtLevel(level: number, opt: ElvoraCascaderOption): void;
+    protected onDocMouse(e: MouseEvent): void;
+    protected readonly triggerStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly listStyle: _angular_core.Signal<Record<string, string>>;
+    protected colStyle(i: number, total: number): Record<string, string>;
+    protected itemStyle(level: number, opt: ElvoraCascaderOption): Record<string, string>;
+}
+
+interface ElvoraTreeNode$1 {
+    value: string;
+    label: string;
+    children?: ElvoraTreeNode$1[];
+    isDisabled?: boolean;
+}
+interface FlatNode {
+    node: ElvoraTreeNode$1;
+    depth: number;
+    hasChildren: boolean;
+}
+declare class ElvoraTreeSelect {
+    private readonly themeService;
+    private readonly host;
+    options: ElvoraTreeNode$1[];
+    value: string | string[];
+    multiple: boolean;
+    placeholder?: string;
+    isDisabled: boolean;
+    defaultExpanded: string[];
+    readonly valueChange: EventEmitter<string | string[]>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly expanded: _angular_core.WritableSignal<Set<string>>;
+    protected readonly flat: _angular_core.Signal<FlatNode[]>;
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    protected toggle(): void;
+    protected toggleExpand(e: Event, v: string): void;
+    protected onSelect(n: ElvoraTreeNode$1): void;
+    protected isSelected(v: string): boolean;
+    protected onDocMouse(e: MouseEvent): void;
+    protected readonly triggerStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly listStyle: _angular_core.Signal<Record<string, string>>;
+    protected rowStyle(f: FlatNode): Record<string, string>;
+    protected caretStyle(): Record<string, string>;
+    protected checkStyle(v: string): Record<string, string>;
+}
+
+interface ElvoraMentionItem {
+    value: string;
+    label?: string;
+}
+declare class ElvoraMentions {
+    private readonly themeService;
+    private textarea?;
+    value: string;
+    options: ElvoraMentionItem[];
+    trigger: string;
+    isDisabled: boolean;
+    readonly valueChange: EventEmitter<string>;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    protected readonly highlight: _angular_core.WritableSignal<number>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private start;
+    protected readonly suggestions: _angular_core.Signal<ElvoraMentionItem[]>;
+    protected onInput(e: Event): void;
+    protected onKeyDown(e: KeyboardEvent): void;
+    protected insert(item: ElvoraMentionItem): void;
+    protected readonly textareaStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly listStyle: _angular_core.Signal<Record<string, string>>;
+    protected itemStyle(active: boolean): Record<string, string>;
+}
+
+interface ElvoraTransferItem {
+    key: string;
+    label: string;
+    isDisabled?: boolean;
+}
+declare class ElvoraTransfer {
+    private readonly themeService;
+    dataSource: ElvoraTransferItem[];
+    value: string[];
+    titles?: [string, string];
+    showSearch: boolean;
+    isDisabled: boolean;
+    readonly valueChange: EventEmitter<string[]>;
+    protected readonly leftSelected: _angular_core.WritableSignal<Set<string>>;
+    protected readonly rightSelected: _angular_core.WritableSignal<Set<string>>;
+    protected readonly leftQuery: _angular_core.WritableSignal<string>;
+    protected readonly rightQuery: _angular_core.WritableSignal<string>;
+    protected readonly leftItems: _angular_core.Signal<ElvoraTransferItem[]>;
+    protected readonly rightItems: _angular_core.Signal<ElvoraTransferItem[]>;
+    protected readonly filteredLeft: _angular_core.Signal<ElvoraTransferItem[]>;
+    protected readonly filteredRight: _angular_core.Signal<ElvoraTransferItem[]>;
+    protected readonly allCheckedLeft: _angular_core.Signal<boolean>;
+    protected readonly allCheckedRight: _angular_core.Signal<boolean>;
+    protected toggleLeft(it: ElvoraTransferItem): void;
+    protected toggleRight(it: ElvoraTransferItem): void;
+    protected toggleAllLeft(): void;
+    protected toggleAllRight(): void;
+    protected moveRight(): void;
+    protected moveLeft(): void;
+    protected readonly listStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly headerStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly searchStyle: _angular_core.Signal<Record<string, string>>;
+    protected readonly searchInputStyle: _angular_core.Signal<Record<string, string>>;
+    protected itemStyle(checked: boolean, it: ElvoraTransferItem): Record<string, string>;
+    protected readonly arrowStyle: _angular_core.Signal<Record<string, string>>;
+}
+
+type ElvoraSortOrder = 'asc' | 'desc' | null;
+interface ElvoraTableColumn<Row = Record<string, unknown>> {
+    key: string;
+    title: string;
+    dataIndex?: keyof Row | string;
+    sortable?: boolean;
+    sorter?: (a: Row, b: Row) => number;
+    width?: number | string;
+    align?: 'left' | 'center' | 'right';
+}
+declare class ElvoraTable<Row extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly themeService;
+    columns: ElvoraTableColumn<Row>[];
+    set dataSource(value: Row[]);
+    get dataSource(): Row[];
+    size: 'sm' | 'md' | 'lg';
+    bordered: boolean;
+    striped: boolean;
+    readonly rowClick: EventEmitter<{
+        row: Row;
+        index: number;
+    }>;
+    protected readonly sortKey: _angular_core.WritableSignal<string | null>;
+    protected readonly sortOrder: _angular_core.WritableSignal<ElvoraSortOrder>;
+    private readonly _data;
+    protected readonly sorted: _angular_core.Signal<Row[]>;
+    protected primary(): string;
+    protected muted(): string;
+    protected onSort(col: ElvoraTableColumn<Row>): void;
+    protected cell(row: Row, col: ElvoraTableColumn<Row>): unknown;
+    protected tableStyle(): {
+        width: string;
+        borderCollapse: string;
+        borderSpacing: number;
+        fontSize: string;
+        color: string;
+        background: string;
+        border: string | undefined;
+        borderRadius: string;
+        overflow: string;
+    };
+    protected theadStyle(): {
+        background: string;
+    };
+    protected thStyle(col: ElvoraTableColumn<Row>): {
+        textAlign: "center" | "right" | "left";
+        padding: string;
+        fontWeight: string;
+        borderBottom: string;
+        width: string | number | undefined;
+        cursor: string | undefined;
+        userSelect: string;
+    };
+    protected tdStyle(col: ElvoraTableColumn<Row>): {
+        padding: string;
+        borderBottom: string;
+        textAlign: "center" | "right" | "left";
+    };
+    protected rowStyle(rowIndex: number): {
+        background: string | undefined;
+    };
+}
+
+interface ElvoraTreeNode {
+    key: string;
+    label: string;
+    children?: ElvoraTreeNode[];
+    isDisabled?: boolean;
+}
+declare class ElvoraTree {
+    private readonly themeService;
+    treeData: ElvoraTreeNode[];
+    set expandedKeys(value: string[]);
+    set selectedKeys(value: string[]);
+    multiple: boolean;
+    readonly expandedKeysChange: EventEmitter<string[]>;
+    readonly selectedKeysChange: EventEmitter<string[]>;
+    readonly nodeSelect: EventEmitter<ElvoraTreeNode>;
+    protected readonly expanded: _angular_core.WritableSignal<Set<string>>;
+    protected readonly selected: _angular_core.WritableSignal<Set<string>>;
+    protected onClick(node: ElvoraTreeNode): void;
+    protected rowStyle(node: ElvoraTreeNode, depth: number): {
+        display: string;
+        alignItems: string;
+        gap: string;
+        padding: string;
+        marginLeft: string;
+        borderRadius: string;
+        background: string | undefined;
+        color: string;
+        cursor: string;
+    };
+}
+
+declare class ElvoraList<T = unknown> {
+    private readonly themeService;
+    dataSource: T[];
+    header?: string;
+    footer?: string;
+    bordered: boolean;
+    size: 'sm' | 'md' | 'lg';
+    divided: boolean;
+    emptyMessage?: string;
+    itemTemplate?: TemplateRef<{
+        $implicit: T;
+        index: number;
+    }>;
+    private padding;
+    protected containerStyle(): {
+        border: string | undefined;
+        borderRadius: string | undefined;
+        background: string;
+        color: string;
+        overflow: string;
+    };
+    protected headerStyle(): {
+        padding: string;
+        fontWeight: string;
+        borderBottom: string;
+    };
+    protected footerStyle(): {
+        padding: string;
+        borderTop: string;
+        color: string;
+    };
+    protected paddingStyle(): {
+        padding: string;
+    };
+    protected rowStyle(isLast: boolean): {
+        padding: string;
+        borderBottom: string | undefined;
+    };
+}
+
+interface ElvoraDescriptionItem {
+    key: string;
+    label: string;
+    value: string;
+    span?: number;
+}
+declare class ElvoraDescriptions {
+    private readonly themeService;
+    items: ElvoraDescriptionItem[];
+    title?: string;
+    columns: number;
+    layout: 'horizontal' | 'vertical';
+    bordered: boolean;
+    size: 'sm' | 'md' | 'lg';
+    private padding;
+    protected rootStyle(): {
+        color: string;
+    };
+    protected gridStyle(): {
+        display: string;
+        gridTemplateColumns: string;
+        border: string | undefined;
+        borderRadius: string | undefined;
+        overflow: string;
+    };
+    protected itemStyle(item: ElvoraDescriptionItem): {
+        gridColumn: string;
+        display: string;
+        gridTemplateColumns: string;
+        borderTop: string | undefined;
+        padding?: undefined;
+        borderRight?: undefined;
+    } | {
+        gridColumn: string;
+        padding: string;
+        borderTop: string | undefined;
+        borderRight: string | undefined;
+        display?: undefined;
+        gridTemplateColumns?: undefined;
+    };
+    protected labelStyle(): {
+        padding: string;
+        background: string | undefined;
+        fontWeight: string;
+        borderRight: string | undefined;
+    };
+    protected valueStyle(): {
+        padding: string;
+    };
+    protected verticalLabelStyle(): {
+        fontWeight: string;
+        color: string;
+        marginBottom: string;
+    };
+}
+
+declare class ElvoraCalendar {
+    private readonly themeService;
+    value: Date | null;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    locale?: string;
+    readonly valueChange: EventEmitter<Date>;
+    protected readonly view: _angular_core.WritableSignal<Date>;
+    protected readonly weekdays: string[];
+    protected readonly matrix: _angular_core.Signal<Date[]>;
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    protected rootStyle(): {
+        background: string;
+        color: string;
+        borderRadius: string;
+        border: string;
+        padding: string;
+        minWidth: string;
+        display: string;
+    };
+    protected dayStyle(d: Date): {
+        minHeight: string;
+        padding: string;
+        border: string;
+        borderRadius: string;
+        cursor: string;
+        background: string;
+        color: string;
+    };
+    protected prev(): void;
+    protected next(): void;
+    protected pick(d: Date): void;
+}
+
+declare class ElvoraStatistic {
+    private readonly themeService;
+    title?: string;
+    value: number | string;
+    precision?: number;
+    prefix?: string;
+    suffix?: string;
+    groupSeparator: boolean;
+    tone: 'default' | 'success' | 'danger' | 'warning' | 'primary';
+    protected formatted(): string;
+    protected rootStyle(): {
+        color: string;
+    };
+    protected titleStyle(): {
+        color: string;
+        fontSize: string;
+        marginBottom: string;
+    };
+    protected toneColor(): string;
+    protected valueRowStyle(): {
+        display: string;
+        alignItems: string;
+        gap: string;
+        color: string;
+        fontSize: string;
+        fontWeight: string;
+        lineHeight: string;
+    };
+}
+
+declare class ElvoraCarousel implements OnDestroy {
+    private readonly themeService;
+    items: string[];
+    set autoplay(value: number);
+    arrows: boolean;
+    dots: boolean;
+    loop: boolean;
+    height: number;
+    readonly currentChange: EventEmitter<number>;
+    protected readonly current: _angular_core.WritableSignal<number>;
+    private timer;
+    protected rootStyle(): {
+        position: string;
+        overflow: string;
+        borderRadius: string;
+        background: string;
+    };
+    protected trackStyle(): {
+        display: string;
+        width: string;
+        height: string;
+        transform: string;
+        transition: string;
+    };
+    protected slideStyle(): {
+        width: string;
+        flex: string;
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+    };
+    protected dotStyle(i: number): {
+        width: string;
+        height: string;
+        borderRadius: string;
+        border: string;
+        background: string;
+        cursor: string;
+    };
+    protected prev(): void;
+    protected next(): void;
+    protected goTo(idx: number): void;
+    private clearTimer;
+    ngOnDestroy(): void;
+}
+
+declare class ElvoraImage {
+    private readonly themeService;
+    src: string;
+    alt: string;
+    fallback?: string;
+    placeholder?: string;
+    preview: boolean;
+    width?: number | string;
+    height?: number | string;
+    fit: 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+    rounded: boolean;
+    protected readonly loaded: _angular_core.WritableSignal<boolean>;
+    protected readonly errored: _angular_core.WritableSignal<boolean>;
+    protected readonly showPreview: _angular_core.WritableSignal<boolean>;
+    protected actualSrc(): string;
+    protected onClick(): void;
+    protected wrapperStyle(): {
+        position: string;
+        display: string;
+        width: string | undefined;
+        height: string | undefined;
+        borderRadius: string | undefined;
+        overflow: string;
+        background: string;
+    };
+    protected imgStyle(): {
+        width: string;
+        height: string;
+        objectFit: "none" | "fill" | "cover" | "contain" | "scale-down";
+        display: string;
+        cursor: string | undefined;
+    };
+    protected overlayStyle(): {
+        position: string;
+        inset: string;
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        color: string;
+    };
+    protected previewStyle(): {
+        position: string;
+        inset: string;
+        background: string;
+        display: string;
+        alignItems: string;
+        justifyContent: string;
+        zIndex: string;
+        cursor: string;
+    };
+}
+
+type ElvoraTimelineStatus = 'default' | 'success' | 'danger' | 'warning' | 'info' | 'primary';
+interface ElvoraTimelineItem {
+    key: string;
+    content: string;
+    label?: string;
+    status?: ElvoraTimelineStatus;
+}
+declare class ElvoraTimeline {
+    private readonly themeService;
+    items: ElvoraTimelineItem[];
+    reverse: boolean;
+    protected resolved(): ElvoraTimelineItem[];
+    protected dotStyle(item: ElvoraTimelineItem): {
+        width: string;
+        height: string;
+        borderRadius: string;
+        background: string;
+        flex: string;
+    };
+    protected lineStyle(): {
+        flex: string;
+        width: string;
+        background: string;
+        marginTop: string;
+    };
+    protected labelStyle(): {
+        color: string;
+        marginBottom: string;
+    };
+    private colorFor;
+}
+
+interface ElvoraCollapseItem {
+    key: string;
+    header: string;
+    content: string;
+    extra?: string;
+    isDisabled?: boolean;
+}
+declare class ElvoraCollapse {
+    private readonly themeService;
+    items: ElvoraCollapseItem[];
+    set activeKeys(value: string[]);
+    accordion: boolean;
+    bordered: boolean;
+    size: 'sm' | 'md' | 'lg';
+    readonly activeKeysChange: EventEmitter<string[]>;
+    protected readonly active: _angular_core.WritableSignal<Set<string>>;
+    protected togglePanel(key: string): void;
+    private padding;
+    protected rootStyle(): {
+        border: string | undefined;
+        borderRadius: string | undefined;
+        background: string;
+        color: string;
+        overflow: string;
+    };
+    protected headerStyle(item: ElvoraCollapseItem, isLast: boolean): {
+        width: string;
+        display: string;
+        alignItems: string;
+        gap: string;
+        padding: string;
+        background: string;
+        color: string;
+        border: string;
+        cursor: string;
+        textAlign: string;
+        fontSize: string;
+        opacity: number;
+        borderBottom: string | undefined;
+    };
+    protected panelStyle(isLast: boolean): {
+        padding: string;
+        borderBottom: string | undefined;
+        background: string;
+    };
+    protected extraStyle(): {
+        color: string;
+    };
+}
+
+type ElvoraAccordionItem = ElvoraCollapseItem;
+declare class ElvoraAccordion {
+    items: ElvoraAccordionItem[];
+    activeKeys: string[];
+    bordered: boolean;
+    size: 'sm' | 'md' | 'lg';
+    readonly activeKeysChange: EventEmitter<string[]>;
+}
+
+interface ElvoraTourStep {
+    /** CSS selector for the element to spotlight. */
+    target?: string;
+    title: string;
+    description?: string;
+}
+declare class ElvoraTour {
+    private readonly themeService;
+    open: boolean;
+    steps: ElvoraTourStep[];
+    mask: boolean;
+    finishLabel: string;
+    readonly openChange: EventEmitter<boolean>;
+    readonly currentChange: EventEmitter<number>;
+    protected readonly current: _angular_core.WritableSignal<number>;
+    protected currentStep(): ElvoraTourStep | undefined;
+    protected close(): void;
+    protected next(): void;
+    protected prev(): void;
+    protected maskStyle(): {
+        position: string;
+        inset: string;
+        background: string;
+        zIndex: string;
+    };
+    protected popoverStyle(): {
+        position: string;
+        top: string;
+        left: string;
+        transform: string;
+        minWidth: string;
+        maxWidth: string;
+        zIndex: string;
+        background: string;
+        color: string;
+        border: string;
+        borderRadius: string;
+        padding: string;
+        boxShadow: string;
+    };
+    protected descStyle(): {
+        color: string;
+        marginBottom: string;
+    };
+    protected counterStyle(): {
+        color: string;
+        fontSize: string;
+    };
+    protected prevBtnStyle(): {
+        padding: string;
+        borderRadius: string;
+        border: string;
+        background: string;
+        color: string;
+        cursor: string;
+    };
+    protected nextBtnStyle(): {
+        padding: string;
+        borderRadius: string;
+        border: string;
+        background: string;
+        color: string;
+        cursor: string;
+    };
+}
+
+type ElvoraFloatButtonTone = 'primary' | 'neutral' | 'danger' | 'success';
+declare class ElvoraFloatButton {
+    private readonly themeService;
+    label?: string;
+    size: number;
+    right: number;
+    bottom: number;
+    tone: ElvoraFloatButtonTone;
+    extended: boolean;
+    isDisabled: boolean;
+    ariaLabel?: string;
+    readonly pressed: EventEmitter<void>;
+    protected buttonStyle(): Record<string, string>;
+}
+
+declare class ElvoraWatermark {
+    private readonly _content;
+    set content(value: string | string[]);
+    font: string;
+    fontSize: number;
+    color: string;
+    rotate: number;
+    gapX: number;
+    gapY: number;
+    protected readonly dataUri: _angular_core.Signal<string>;
+    protected rootStyle(): Record<string, string>;
+    private buildDataUri;
+}
+
+declare class ElvoraQrCode {
+    private readonly _value;
+    private readonly _level;
+    set value(v: string);
+    set level(l: ErrorCorrection);
+    size: number;
+    foreground: string;
+    background: string;
+    ariaLabel?: string;
+    protected readonly matrixData: _angular_core.Signal<_elvora_core.QRMatrix>;
+    protected readonly matrix: _angular_core.Signal<boolean[][]>;
+    protected readonly matrixSize: _angular_core.Signal<number>;
+}
+
+declare class ElvoraSplitter {
+    private readonly themeService;
+    protected readonly Math: Math;
+    container: ElementRef<HTMLDivElement>;
+    direction: 'horizontal' | 'vertical';
+    set splitRatio(value: number);
+    minRatio: number;
+    maxRatio: number;
+    handleSize: number;
+    readonly splitRatioChange: EventEmitter<number>;
+    protected readonly split: _angular_core.WritableSignal<number>;
+    private dragging;
+    private startCoord;
+    private startSplit;
+    protected rootStyle(): Record<string, string>;
+    protected firstPaneStyle(): Record<string, string>;
+    protected secondPaneStyle(): Record<string, string>;
+    protected handleStyle(): Record<string, string>;
+    protected onPointerDown(event: PointerEvent): void;
+    private onPointerMove;
+    protected onKeyDown(event: KeyboardEvent): void;
+}
+
+declare class ElvoraAffix implements AfterViewInit, OnDestroy {
+    placeholder: ElementRef<HTMLDivElement>;
+    wrapper: ElementRef<HTMLDivElement>;
+    offsetTop?: number;
+    offsetBottom?: number;
+    readonly affixedChange: EventEmitter<boolean>;
+    protected readonly affixed: _angular_core.WritableSignal<boolean>;
+    private size;
+    private boundUpdate;
+    protected placeholderStyle(): Record<string, string | undefined>;
+    protected wrapperStyle(): Record<string, string | undefined>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private update;
+}
+
+interface ElvoraSpeedDialAction {
+    key: string;
+    label: string;
+    isDisabled?: boolean;
+}
+declare class ElvoraSpeedDial {
+    private readonly themeService;
+    actions: ElvoraSpeedDialAction[];
+    right: number;
+    bottom: number;
+    direction: 'up' | 'down' | 'left' | 'right';
+    ariaLabel?: string;
+    readonly openChange: EventEmitter<boolean>;
+    readonly actionPress: EventEmitter<ElvoraSpeedDialAction>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected toggle(): void;
+    protected onAction(action: ElvoraSpeedDialAction): void;
+    protected triggerStyle(): Record<string, string>;
+    protected actionStyle(idx: number): {
+        right: string;
+        bottom: string;
+    } | {
+        right: string;
+        top: string;
+    } | {
+        bottom: string;
+        left: string;
+    };
+}
+
+declare class ElvoraBackdrop {
+    private readonly themeService;
+    open: boolean;
+    tint?: string;
+    invisible: boolean;
+    readonly closed: EventEmitter<void>;
+    protected rootStyle(): Record<string, string>;
+}
+
+interface ElvoraImageListItem {
+    key: string;
+    src?: string;
+    alt?: string;
+    caption?: string;
+    cols?: number;
+    rows?: number;
+}
+declare class ElvoraImageList {
+    private readonly themeService;
+    items: ElvoraImageListItem[];
+    cols: number;
+    gap: number;
+    rowHeight: number;
+    protected rootStyle(): Record<string, string>;
+    protected cellStyle(item: ElvoraImageListItem): Record<string, string | undefined>;
+    protected imageStyle(): Record<string, string>;
+    protected captionStyle(): Record<string, string>;
+}
+
+declare class ElvoraSimplePagination {
+    private readonly themeService;
+    private readonly _total;
+    private readonly _pageSize;
+    private readonly _current;
+    set total(v: number);
+    set pageSize(v: number);
+    get pageSize(): number;
+    set current(v: number);
+    showJumper: boolean;
+    showSizeChanger: boolean;
+    pageSizeOptions: number[];
+    readonly currentChange: EventEmitter<number>;
+    readonly pageSizeChange: EventEmitter<number>;
+    protected totalPages(): number;
+    protected currentPage(): number;
+    protected goTo(page: number): void;
+    protected onSizeChange(event: Event): void;
+    protected onJump(event: Event): void;
+    protected rootStyle(): Record<string, string>;
+    protected btnStyle(disabled: boolean): Record<string, string>;
+    protected labelStyle(): Record<string, string>;
+    protected selectStyle(): Record<string, string>;
+    protected jumperStyle(): {
+        fontSize: string;
+        color: string;
+        display: string;
+        alignItems: string;
+        gap: string;
+    };
+    protected inputStyle(): Record<string, string>;
+}
+declare class ElvoraMiniPagination {
+    private readonly themeService;
+    private readonly _total;
+    private readonly _pageSize;
+    private readonly _current;
+    set total(v: number);
+    set pageSize(v: number);
+    set current(v: number);
+    readonly currentChange: EventEmitter<number>;
+    protected totalPages(): number;
+    protected currentPage(): number;
+    protected goTo(page: number): void;
+    protected rootStyle(): Record<string, string>;
+    protected btnStyle(disabled: boolean): Record<string, string>;
+}
+
+interface ElvoraStepperStep {
+    key: string;
+    label: string;
+    description?: string;
+    optional?: boolean;
+}
+declare class ElvoraStepper {
+    private readonly themeService;
+    private readonly _active;
+    steps: ElvoraStepperStep[];
+    set active(value: number);
+    orientation: 'horizontal' | 'vertical';
+    showNavigation: boolean;
+    nextLabel: string;
+    prevLabel: string;
+    finishLabel: string;
+    readonly activeChange: EventEmitter<number>;
+    readonly finished: EventEmitter<void>;
+    protected activeStep(): number;
+    protected goTo(idx: number): void;
+    protected next(): void;
+    protected prev(): void;
+    protected trackStyle(): Record<string, string>;
+    protected stepStyle(): Record<string, string | undefined>;
+    protected circleStyle(idx: number): Record<string, string>;
+    protected labelStyle(idx: number): Record<string, string>;
+    protected descStyle(): Record<string, string>;
+    protected connectorStyle(idx: number): Record<string, string>;
+    protected navStyle(): Record<string, string>;
+    protected navBtnStyle(variant: 'primary' | 'outline'): Record<string, string>;
+}
+
+declare class ElvoraToggleButton {
+    private readonly themeService;
+    value?: string;
+    size: ElvoraSize;
+    isDisabled: boolean;
+    set selectedValue(value: boolean);
+    readonly selectedChange: EventEmitter<boolean>;
+    protected readonly selected: _angular_core.WritableSignal<boolean>;
+    protected onToggle(): void;
+    protected buttonStyle(): Record<string, string>;
+    private sizePadding;
+}
+
+declare class ElvoraButtonGroup {
+    orientation: 'horizontal' | 'vertical';
+    protected rootStyle(): Record<string, string>;
+}
+
+declare class ElvoraChipInput {
+    private readonly themeService;
+    inputEl: ElementRef<HTMLInputElement>;
+    set value(v: string[]);
+    placeholder?: string;
+    isDisabled: boolean;
+    unique: boolean;
+    maxChips?: number;
+    ariaLabel?: string;
+    readonly valueChange: EventEmitter<string[]>;
+    protected readonly chips: _angular_core.WritableSignal<string[]>;
+    protected readonly draft: _angular_core.WritableSignal<string>;
+    protected focusInput(): void;
+    protected onInput(event: Event): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected commit(): void;
+    protected addChip(raw: string): void;
+    protected remove(idx: number): void;
+    protected rootStyle(): Record<string, string>;
+    protected chipStyle(): Record<string, string>;
+    protected closeBtnStyle(): Record<string, string>;
+    protected inputStyle(): Record<string, string>;
+}
+
+interface ElvoraProTableColumn<Row = Record<string, unknown>> extends ElvoraTableColumn<Row> {
+    searchable?: boolean;
+}
+declare class ElvoraProTable<Row extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly themeService;
+    title: string;
+    columns: ElvoraProTableColumn<Row>[];
+    set dataSource(value: Row[]);
+    get dataSource(): Row[];
+    search: boolean;
+    searchPlaceholder: string;
+    empty: string;
+    readonly rowClick: EventEmitter<{
+        row: Row;
+        index: number;
+    }>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private readonly _data;
+    protected readonly filtered: _angular_core.Signal<Row[]>;
+    protected fgColor(): string;
+    protected mutedColor(): string;
+}
+
+type ElvoraProFormFieldType = 'text' | 'password' | 'email' | 'number' | 'textarea' | 'switch' | 'checkbox' | 'select';
+interface ElvoraProFormField {
+    name: string;
+    label?: string;
+    type: ElvoraProFormFieldType;
+    placeholder?: string;
+    hint?: string;
+    required?: boolean;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    options?: ElvoraSelectOption[];
+    validate?: (value: unknown, values: Record<string, unknown>) => string | undefined;
+}
+declare class ElvoraProForm {
+    private readonly themeService;
+    fields: ElvoraProFormField[];
+    set initialValues(value: Record<string, unknown> | null | undefined);
+    submitLabel: string;
+    resetLabel?: string;
+    isSubmitting: boolean;
+    readonly formSubmit: EventEmitter<Record<string, unknown>>;
+    readonly valuesChange: EventEmitter<Record<string, unknown>>;
+    private readonly _initial;
+    private readonly _values;
+    private readonly _errors;
+    protected strValue(name: string): string;
+    protected numberValue(name: string): number;
+    protected boolValue(name: string): boolean;
+    protected error(name: string): string | undefined;
+    protected mutedColor(): string;
+    protected dangerColor(): string;
+    setValue(name: string, value: unknown): void;
+    reset(): void;
+    handleSubmit(): void;
+}
+
+interface ElvoraProLayoutMenuItem {
+    key: string;
+    label: string;
+    icon?: IconName;
+    children?: ElvoraProLayoutMenuItem[];
+}
+interface ElvoraProLayoutUser {
+    name: string;
+    avatar?: string;
+    caption?: string;
+}
+declare class ElvoraProLayout {
+    private readonly themeService;
+    brand?: string;
+    menu: ElvoraProLayoutMenuItem[];
+    user?: ElvoraProLayoutUser;
+    sidebarWidth: number;
+    headerVisible: boolean;
+    set selectedKey(value: string | null | undefined);
+    readonly selectionChange: EventEmitter<string>;
+    protected readonly active: _angular_core.WritableSignal<string | null>;
+    onSelect(key: string): void;
+    protected bg(): string;
+    protected surface(): string;
+    protected border(): string;
+    protected fg(): string;
+    protected muted(): string;
+    protected primarySubtle(): string;
+    protected primaryFg(): string;
+}
+
+type ElvoraDataGridSortOrder = 'asc' | 'desc' | null;
+interface ElvoraDataGridColumn<Row = Record<string, unknown>> {
+    key: string;
+    title: string;
+    dataIndex?: keyof Row | string;
+    width?: number;
+    sortable?: boolean;
+    sorter?: (a: Row, b: Row) => number;
+    align?: 'left' | 'center' | 'right';
+}
+declare class ElvoraDataGrid<Row extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly themeService;
+    columns: ElvoraDataGridColumn<Row>[];
+    set dataSource(value: Row[]);
+    get dataSource(): Row[];
+    rowHeight: number;
+    height: number;
+    overscan: number;
+    empty: string;
+    readonly rowClick: EventEmitter<{
+        row: Row;
+        index: number;
+    }>;
+    private readonly _data;
+    protected readonly sortKey: _angular_core.WritableSignal<string | null>;
+    protected readonly sortOrder: _angular_core.WritableSignal<ElvoraDataGridSortOrder>;
+    protected readonly scrollTop: _angular_core.WritableSignal<number>;
+    protected readonly sorted: _angular_core.Signal<Row[]>;
+    protected readonly totalHeight: _angular_core.Signal<number>;
+    protected readonly visible: _angular_core.Signal<{
+        row: Row;
+        index: number;
+        top: number;
+        key: string;
+    }[]>;
+    trackEntry: (_: number, entry: {
+        key: string;
+    }) => string;
+    protected onScroll(target: HTMLElement): void;
+    toggleSort(key: string): void;
+    protected cell(row: Row, col: ElvoraDataGridColumn<Row>): unknown;
+    protected border(): string;
+    protected surface(): string;
+    protected headerBg(): string;
+    protected mutedColor(): string;
+}
+
+/**
+ * Provide a theme to an Angular app:
+ *
+ * ```ts
+ * import { ApplicationConfig } from '@angular/core';
+ * import { provideElvoraTheme } from '@elvora/angular';
+ * import { darkTheme } from '@elvora/themes';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [provideElvoraTheme(darkTheme)],
+ * };
+ * ```
+ */
+declare const ELVORA_THEME: InjectionToken<ElvoraTheme>;
+declare const ELVORA_DIRECTION: InjectionToken<Direction$1>;
+declare function provideElvoraTheme(theme?: ElvoraTheme, direction?: Direction$1): ({
+    provide: InjectionToken<ElvoraTheme>;
+    useValue: ElvoraTheme;
+} | {
+    provide: InjectionToken<Direction$1>;
+    useValue: Direction$1;
+})[];
+declare class ElvoraThemeService {
+    private readonly providedTheme;
+    private readonly providedDirection;
+    private readonly themeSignal;
+    private readonly directionSignal;
+    readonly theme: Signal<ElvoraTheme>;
+    readonly direction: Signal<Direction$1>;
+    setTheme(theme: ElvoraTheme): void;
+    setDirection(direction: Direction$1): void;
+}
+
+export { ELVORA_DIRECTION, ELVORA_THEME, ElvoraAccordion, type ElvoraAccordionItem, ElvoraAffix, ElvoraAlert, ElvoraAnchor, type ElvoraAnchorLink, ElvoraAutoComplete, type ElvoraAutoCompleteOption, ElvoraAvatar, ElvoraBackTop, ElvoraBackdrop, ElvoraBadge, ElvoraBox, ElvoraBreadcrumb, type ElvoraBreadcrumbItem, ElvoraButton, ElvoraButtonGroup, ElvoraCalendar, ElvoraCard, ElvoraCardBody, ElvoraCardFooter, ElvoraCardHeader, ElvoraCarousel, ElvoraCascader, type ElvoraCascaderOption, ElvoraCheckbox, ElvoraChipInput, ElvoraCollapse, type ElvoraCollapseItem, ElvoraColorPicker, ElvoraContainer, ElvoraDataGrid, type ElvoraDataGridColumn, type ElvoraDataGridSortOrder, ElvoraDatePicker, type ElvoraDateRange, ElvoraDateRangePicker, type ElvoraDescriptionItem, ElvoraDescriptions, ElvoraDivider, ElvoraDrawer, ElvoraEmpty, ElvoraFloatButton, type ElvoraFloatButtonTone, ElvoraForm, ElvoraFormField, ElvoraFormState, ElvoraGrid, ElvoraGridItem, ElvoraHStack, ElvoraIcon, ElvoraIconButton, ElvoraImage, ElvoraImageList, type ElvoraImageListItem, ElvoraInput, ElvoraLabel, ElvoraList, type ElvoraMentionItem, ElvoraMentions, ElvoraMenu, type ElvoraMenuItem, ElvoraMiniPagination, ElvoraModal, ElvoraNumberInput, ElvoraPagination, ElvoraPopover, ElvoraProForm, type ElvoraProFormField, type ElvoraProFormFieldType, ElvoraProLayout, type ElvoraProLayoutMenuItem, type ElvoraProLayoutUser, ElvoraProTable, type ElvoraProTableColumn, ElvoraProgress, ElvoraQrCode, ElvoraRadio, ElvoraRadioGroup, ElvoraRate, ElvoraResult, type ElvoraResultStatus, ElvoraSegmented, type ElvoraSegmentedOption, ElvoraSelect, type ElvoraSelectOption, ElvoraSimplePagination, ElvoraSkeleton, ElvoraSlider, type ElvoraSortOrder, ElvoraSpeedDial, type ElvoraSpeedDialAction, ElvoraSpinner, ElvoraSplitter, ElvoraStack, ElvoraStatistic, type ElvoraStep, ElvoraStepper, type ElvoraStepperStep, ElvoraSteps, ElvoraSwitch, ElvoraTabTemplate, ElvoraTable, type ElvoraTableColumn, ElvoraTabs, ElvoraTag, ElvoraTextarea, ElvoraThemeService, ElvoraTimePicker, type ElvoraTimeValue, ElvoraTimeline, type ElvoraTimelineItem, type ElvoraTimelineStatus, ElvoraToastHost, type ElvoraToastOptions, ElvoraToastService, ElvoraToggleButton, ElvoraTooltip, ElvoraTour, type ElvoraTourStep, ElvoraTransfer, type ElvoraTransferItem, ElvoraTree, type ElvoraTreeNode as ElvoraTreeDataNode, type ElvoraTreeNode$1 as ElvoraTreeNode, ElvoraTreeSelect, ElvoraUpload, type ElvoraUploadFile, ElvoraVStack, ElvoraWatermark, provideElvoraTheme };