angular-visuals 0.1.3 → 0.2.0

package/types/angular-visuals.d.ts

@@ -4,6 +4,22 @@ import { ConnectedPosition } from '@angular/cdk/overlay';
 import { ControlValueAccessor, NgControl } from '@angular/forms';
 import { SafeHtml } from '@angular/platform-browser';
 
+type AvBottomnavHighlight = 'floating-circle' | 'normal' | 'static' | 'inline-label' | 'underline';
+type AvBottomnavPosition = 'static' | 'sticky' | 'fixed';
+declare class AvBottomnav {
+    private readonly config;
+    private readonly themeService;
+    ariaLabel: _angular_core.InputSignal<string>;
+    highlight: _angular_core.InputSignal<AvBottomnavHighlight>;
+    position: _angular_core.InputSignal<AvBottomnavPosition>;
+    safeArea: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    variant: _angular_core.InputSignal<string>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    readonly navClasses: _angular_core.Signal<Record<string, boolean>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvBottomnav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvBottomnav, "av-bottomnav", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "highlight": { "alias": "highlight"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "safeArea": { "alias": "safeArea"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[floatingAction],[avBottomnavAction]", "*"], true, never>;
+}
+
 declare class AvNavDropdown {
     private readonly config;
     private readonly themeService;
@@ -139,6 +155,66 @@ declare class AvStack {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvStack, "av-stack", never, { "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+type AvBoxPadding = number | 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type AvBoxRounded = number | 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+type AvBoxSurface = 'transparent' | 'surface' | 'muted' | 'raised';
+declare class AvBox {
+    bordered: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    padding: _angular_core.InputSignal<AvBoxPadding>;
+    rounded: _angular_core.InputSignal<AvBoxRounded>;
+    shadow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    surface: _angular_core.InputSignal<AvBoxSurface>;
+    get borderedClass(): boolean;
+    get shadowClass(): boolean;
+    get paddingStyle(): string;
+    get roundedStyle(): string;
+    get backgroundStyle(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvBox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvBox, "av-box", never, { "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "surface": { "alias": "surface"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class AvCenter {
+    maxWidth: _angular_core.InputSignal<string | number | null>;
+    minHeight: _angular_core.InputSignal<string | number | null>;
+    get maxWidthStyle(): string;
+    get minHeightStyle(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvCenter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvCenter, "av-center", never, { "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type AvHeadingAlign = 'start' | 'center' | 'end';
+declare class AvHeading {
+    align: _angular_core.InputSignal<AvHeadingAlign>;
+    level: _angular_core.InputSignalWithTransform<number, unknown>;
+    muted: _angular_core.InputSignal<string>;
+    size: _angular_core.InputSignalWithTransform<number | null, unknown>;
+    readonly safeLevel: _angular_core.Signal<number>;
+    readonly visualLevel: _angular_core.Signal<number>;
+    readonly classes: _angular_core.Signal<Record<string, boolean>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvHeading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvHeading, "av-heading", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "muted": { "alias": "muted"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class AvKbd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvKbd, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvKbd, "av-kbd", never, {}, {}, never, ["*"], true, never>;
+}
+
+type AvSpacerAxis = 'block' | 'inline';
+declare class AvSpacer {
+    axis: _angular_core.InputSignal<AvSpacerAxis>;
+    size: _angular_core.InputSignal<string | number>;
+    get inlineClass(): boolean;
+    get sizeStyle(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvSpacer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvSpacer, "av-spacer", never, { "axis": { "alias": "axis"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AvVisuallyHidden {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvVisuallyHidden, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvVisuallyHidden, "av-visually-hidden", never, {}, {}, never, ["*"], true, never>;
+}
+
 type AvTooltipPosition = 'top' | 'right' | 'bottom' | 'left';
 declare class AvTooltip implements OnDestroy {
     private readonly config;
@@ -228,6 +304,159 @@ declare class AvDropdownItem {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvDropdownItem, "button[av-dropdown-item], a[av-dropdown-item]", never, { "danger": { "alias": "danger"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+type AvDialogRole = 'dialog' | 'alertdialog';
+declare class AvDialog implements OnDestroy {
+    private readonly config;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly themeService;
+    ariaLabel: _angular_core.InputSignal<string>;
+    ariaLabelledby: _angular_core.InputSignal<string>;
+    closeLabel: _angular_core.InputSignal<string>;
+    closeOnBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    open: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    role: _angular_core.InputSignal<AvDialogRole>;
+    showClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    variant: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    openChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly internalOpen;
+    private previousBodyOverflow;
+    private restoreFocusTo;
+    readonly dialogId: string;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    constructor();
+    get widthStyle(): string;
+    openDialog(): void;
+    close(): void;
+    handleBackdropClick(): void;
+    handleEscape(event: Event): void;
+    private setOpen;
+    private syncBodyScroll;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvDialog, "av-dialog", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, ["[av-dialog-trigger],[avDialogTrigger]", "[dialogHeader],[avDialogHeader]", "*", "[dialogFooter],[avDialogFooter]"], true, never>;
+}
+
+type AvDrawerPlacement = 'left' | 'right' | 'bottom';
+declare class AvDrawer implements OnDestroy {
+    private readonly config;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly themeService;
+    ariaLabel: _angular_core.InputSignal<string>;
+    closeLabel: _angular_core.InputSignal<string>;
+    closeOnBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    open: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    placement: _angular_core.InputSignal<AvDrawerPlacement>;
+    showClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    variant: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number>;
+    openChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly internalOpen;
+    private previousBodyOverflow;
+    private restoreFocusTo;
+    readonly drawerId: string;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly drawerClasses: _angular_core.Signal<Record<string, boolean>>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    constructor();
+    get sizeStyle(): string;
+    openDrawer(): void;
+    close(): void;
+    handleBackdropClick(): void;
+    handleEscape(event: Event): void;
+    private setOpen;
+    private syncBodyScroll;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvDrawer, "av-drawer", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, ["[av-drawer-trigger],[avDrawerTrigger]", "[drawerHeader],[avDrawerHeader]", "*", "[drawerFooter],[avDrawerFooter]"], true, never>;
+}
+
+type AvPopoverPlacement = 'top' | 'right' | 'bottom' | 'left' | 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+declare class AvPopover {
+    private readonly config;
+    private readonly themeService;
+    ariaLabel: _angular_core.InputSignal<string>;
+    closeOnBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeOnContentClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    matchTriggerWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    offset: _angular_core.InputSignalWithTransform<number, unknown>;
+    open: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    placement: _angular_core.InputSignal<AvPopoverPlacement>;
+    variant: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | number | null>;
+    openChange: _angular_core.OutputEmitterRef<boolean>;
+    triggerEl: ElementRef<HTMLElement>;
+    private readonly internalOpen;
+    readonly panelId: string;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly overlayPositions: _angular_core.Signal<ConnectedPosition[]>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    constructor();
+    get widthStyle(): string | null;
+    toggle(): void;
+    close(): void;
+    handleBackdropClick(): void;
+    handlePanelClick(): void;
+    handleTriggerKeydown(event: KeyboardEvent): void;
+    private setOpen;
+    private positionsFor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvPopover, "av-popover", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "closeOnContentClick": { "alias": "closeOnContentClick"; "required": false; "isSignal": true; }; "matchTriggerWidth": { "alias": "matchTriggerWidth"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, ["[av-popover-trigger],[avPopoverTrigger]", "*"], true, never>;
+}
+
+type AvToastVariant = 'default' | 'info' | 'success' | 'warning' | 'danger';
+declare class AvToast {
+    private readonly config;
+    private readonly themeService;
+    dismissible: _angular_core.InputSignal<boolean>;
+    message: _angular_core.InputSignal<string>;
+    title: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<AvToastVariant>;
+    dismissed: _angular_core.OutputEmitterRef<void>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    private colorVariant;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvToast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvToast, "av-toast", never, { "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+interface AvToastOptions {
+    dismissible?: boolean;
+    duration?: number;
+    message: string;
+    title?: string;
+    variant?: AvToastVariant;
+}
+declare class AvToastRef {
+    readonly id: string;
+    private readonly closeFn;
+    constructor(id: string, closeFn: () => void);
+    close(): void;
+}
+declare class ToastService implements OnDestroy {
+    private readonly injector;
+    private readonly overlay;
+    private overlayRef?;
+    private viewport?;
+    private readonly timers;
+    show(message: string, options?: Omit<AvToastOptions, 'message'>): AvToastRef;
+    show(options: AvToastOptions): AvToastRef;
+    info(message: string, options?: Omit<AvToastOptions, 'message' | 'variant'>): AvToastRef;
+    success(message: string, options?: Omit<AvToastOptions, 'message' | 'variant'>): AvToastRef;
+    warning(message: string, options?: Omit<AvToastOptions, 'message' | 'variant'>): AvToastRef;
+    danger(message: string, options?: Omit<AvToastOptions, 'message' | 'variant'>): AvToastRef;
+    dismiss(id: string): void;
+    dismissAll(): void;
+    ngOnDestroy(): void;
+    private ensureViewport;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
 declare class AvTextArea implements ControlValueAccessor, AfterViewInit {
     ngControl: NgControl;
     private readonly config;
@@ -372,7 +601,7 @@ declare class AvSwitch implements ControlValueAccessor {
     rounded: _angular_core.InputSignal<number | "xs" | "sm" | "md" | "lg" | "xl" | "full">;
     checked: _angular_core.ModelSignal<boolean>;
     disabled: _angular_core.InputSignal<boolean>;
-    protected formDisabled: boolean;
+    protected readonly formDisabled: _angular_core.WritableSignal<boolean>;
     readonly isDisabled: _angular_core.Signal<boolean>;
     readonly themeVars: _angular_core.Signal<Record<string, string>>;
     private onChange;
@@ -485,6 +714,7 @@ declare class AvSelect implements ControlValueAccessor {
     disabled: _angular_core.WritableSignal<boolean>;
     onChange: any;
     onTouched: any;
+    readonly overlayPositions: ConnectedPosition[];
     constructor(ngControl: NgControl);
     get roundedStyle(): string;
     get themeVars(): Record<string, string>;
@@ -635,6 +865,7 @@ declare class AvDateTimePicker implements ControlValueAccessor {
     readonly minuteOptions: number[];
     onChange: (value: string | null) => void;
     onTouched: () => void;
+    readonly overlayPositions: ConnectedPosition[];
     readonly activeVariant: _angular_core.Signal<string>;
     readonly themeVars: _angular_core.Signal<Record<string, string>>;
     calendarDays: _angular_core.Signal<(Date | null)[]>;
@@ -696,6 +927,7 @@ declare class AvMultiSelect implements ControlValueAccessor {
     disabled: _angular_core.WritableSignal<boolean>;
     onChange: (value: any[]) => void;
     onTouched: () => void;
+    readonly overlayPositions: ConnectedPosition[];
     readonly activeVariant: _angular_core.Signal<string>;
     readonly themeVars: _angular_core.Signal<Record<string, string>>;
     filteredData: _angular_core.Signal<any[]>;
@@ -745,6 +977,113 @@ declare class AvGrid {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvGrid, "div[av-grid]", never, { "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+type AvAlertAppearance = 'soft' | 'outline' | 'solid';
+type AvAlertVariant = 'default' | 'info' | 'success' | 'warning' | 'danger';
+declare class AvAlert {
+    private readonly config;
+    private readonly themeService;
+    appearance: _angular_core.InputSignal<AvAlertAppearance>;
+    dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    icon: _angular_core.InputSignal<string>;
+    showIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    title: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<AvAlertVariant>;
+    dismissed: _angular_core.OutputEmitterRef<void>;
+    readonly alertClasses: _angular_core.Signal<Record<string, boolean>>;
+    readonly indicatorText: _angular_core.Signal<"✓" | "!" | "i" | "•">;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    private colorVariant;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvAlert, "av-alert", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+declare class AvEmptyState {
+    private readonly config;
+    private readonly themeService;
+    description: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string>;
+    title: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<string>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvEmptyState, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvEmptyState, "av-empty-state", never, { "description": { "alias": "description"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[actions],[emptyActions]"], true, never>;
+}
+
+type AvSkeletonRounded = number | 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+declare class AvSkeleton {
+    animated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    circle: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    height: _angular_core.InputSignal<string | number>;
+    lines: _angular_core.InputSignalWithTransform<number, unknown>;
+    rounded: _angular_core.InputSignal<AvSkeletonRounded>;
+    width: _angular_core.InputSignal<string | number>;
+    readonly lineItems: _angular_core.Signal<number[]>;
+    cssLength(value: number | string): string;
+    lineWidth(index: number): string;
+    roundedStyle(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvSkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvSkeleton, "av-skeleton", never, { "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "circle": { "alias": "circle"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AvAvatarSize = 'sm' | 'md' | 'lg' | number;
+declare class AvAvatar {
+    private readonly config;
+    private readonly themeService;
+    alt: _angular_core.InputSignal<string>;
+    name: _angular_core.InputSignal<string>;
+    rounded: _angular_core.InputSignal<boolean>;
+    size: _angular_core.InputSignal<AvAvatarSize>;
+    src: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<string>;
+    readonly imageFailed: _angular_core.WritableSignal<boolean>;
+    readonly initials: _angular_core.Signal<string>;
+    readonly sizeStyle: _angular_core.Signal<string>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    handleImageError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvAvatar, "av-avatar", never, { "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AvButtonGroupOrientation = 'horizontal' | 'vertical';
+type AvButtonGroupValue = string | number | null;
+declare class AvButtonGroup {
+    private readonly config;
+    private readonly internalValue;
+    value: _angular_core.InputSignal<AvButtonGroupValue>;
+    selectable: _angular_core.InputSignal<boolean>;
+    attached: _angular_core.InputSignal<boolean>;
+    orientation: _angular_core.InputSignal<AvButtonGroupOrientation>;
+    variant: _angular_core.InputSignal<string>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    valueChange: _angular_core.OutputEmitterRef<AvButtonGroupValue>;
+    selectionChange: _angular_core.OutputEmitterRef<AvButtonGroupValue>;
+    readonly currentValue: _angular_core.Signal<AvButtonGroupValue>;
+    get verticalClass(): boolean;
+    get attachedClass(): boolean;
+    get role(): string;
+    get label(): string;
+    get ariaOrientation(): AvButtonGroupOrientation;
+    get accent(): string;
+    get accentSoft(): string;
+    select(value: AvButtonGroupValue): void;
+    isSelected(value: AvButtonGroupValue): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvButtonGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvButtonGroup, "av-button-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "attached": { "alias": "attached"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "selectionChange": "selectionChange"; }, never, ["*"], true, never>;
+}
+declare class AvButtonGroupItem {
+    private readonly group;
+    value: _angular_core.InputSignal<AvButtonGroupValue>;
+    valueKebab: _angular_core.InputSignal<AvButtonGroupValue>;
+    private readonly itemValue;
+    protected readonly itemClass = true;
+    get selectedClass(): boolean;
+    get ariaPressed(): boolean | null;
+    handleClick(): void;
+    handleKeydown(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvButtonGroupItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AvButtonGroupItem, "[avButtonGroupItem], [av-button-group-item]", never, { "value": { "alias": "avButtonGroupItem"; "required": false; "isSignal": true; }; "valueKebab": { "alias": "av-button-group-item"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 type AvCardAppearance = 'outlined' | 'filled' | 'elevated';
 type AvCardPadding = number | 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 type AvCardRounded = number | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -764,6 +1103,23 @@ declare class AvCard {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvCard, "av-card", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[header]", "[content]", "*", "[footer]"], true, never>;
 }
 
+type AvChipAppearance = 'soft' | 'outline' | 'solid';
+declare class AvChip {
+    private readonly config;
+    private readonly themeService;
+    appearance: _angular_core.InputSignal<AvChipAppearance>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    icon: _angular_core.InputSignal<string>;
+    removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    variant: _angular_core.InputSignal<string>;
+    removed: _angular_core.OutputEmitterRef<void>;
+    readonly classes: _angular_core.Signal<Record<string, boolean>>;
+    readonly themeVars: _angular_core.Signal<Record<string, string>>;
+    remove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvChip, "av-chip, av-tag", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+}
+
 interface AvRegisteredIcon {
     name: string;
     svg: SafeHtml;
@@ -966,6 +1322,22 @@ interface PageChangeEvent {
     page: number;
     pageSize: number;
 }
+declare class AvSortableColumn {
+    private readonly table;
+    field: _angular_core.InputSignal<string>;
+    fieldCamel: _angular_core.InputSignal<string>;
+    readonly sortField: _angular_core.Signal<string>;
+    readonly active: _angular_core.Signal<boolean>;
+    readonly sortableClass = true;
+    get activeClass(): boolean;
+    readonly role = "button";
+    readonly tabindex = "0";
+    get ariaSort(): 'ascending' | 'descending' | 'none';
+    sort(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvSortableColumn, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AvSortableColumn, "[av-sortable-column], [avSortableColumn]", never, { "field": { "alias": "av-sortable-column"; "required": false; "isSignal": true; }; "fieldCamel": { "alias": "avSortableColumn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 declare class AvTable<T = any> {
     private readonly config;
     variant: _angular_core.InputSignal<string>;
@@ -996,6 +1368,159 @@ declare class AvTable<T = any> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvTable<any>, "av-table", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "totalRecords": { "alias": "totalRecords"; "required": false; "isSignal": true; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; "isSignal": true; }; "currentPageLabel": { "alias": "currentPageLabel"; "required": false; "isSignal": true; }; "sortField": { "alias": "sortField"; "required": false; "isSignal": true; }; "sortOrder": { "alias": "sortOrder"; "required": false; "isSignal": true; }; }, { "onSort": "onSort"; "onPage": "onPage"; }, ["headerTemplate", "bodyTemplate"], never, true, never>;
 }
 
+type AvAccordionVariant = 'default' | 'separated';
+declare class AvAccordion {
+    private readonly config;
+    private readonly items;
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    variant: _angular_core.InputSignal<string>;
+    appearance: _angular_core.InputSignal<AvAccordionVariant>;
+    get separatedClass(): boolean;
+    get accent(): string;
+    register(item: AvAccordionItem): void;
+    unregister(item: AvAccordionItem): void;
+    toggleItem(item: AvAccordionItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvAccordion, "av-accordion", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AvAccordionItem implements OnDestroy {
+    private readonly accordion;
+    private readonly expandedState;
+    title: _angular_core.InputSignal<string>;
+    description: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    expandedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly isExpanded: _angular_core.Signal<boolean>;
+    set expanded(value: boolean);
+    get expandedClass(): boolean;
+    get disabledClass(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    toggle(): void;
+    setExpanded(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvAccordionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvAccordionItem, "av-accordion-item", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, ["[title], [accordionTitle]", "*"], true, never>;
+    static ngAcceptInputType_expanded: unknown;
+}
+
+type AvTimelineDensity = 'comfortable' | 'compact';
+type AvTimelineSide = 'start' | 'alternate';
+declare class AvTimeline {
+    density: _angular_core.InputSignal<AvTimelineDensity>;
+    side: _angular_core.InputSignal<AvTimelineSide>;
+    get compactClass(): boolean;
+    get alternateClass(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvTimeline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvTimeline, "av-timeline", never, { "density": { "alias": "density"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AvTimelineItem {
+    title: _angular_core.InputSignal<string>;
+    description: _angular_core.InputSignal<string>;
+    time: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<string>;
+    get accent(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvTimelineItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvTimelineItem, "av-timeline-item", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "time": { "alias": "time"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface AvBreadcrumbItem {
+    label: string;
+    href?: string;
+    route?: string | any[] | null;
+    icon?: string;
+    current?: boolean;
+}
+declare class AvBreadcrumb {
+    items: _angular_core.InputSignal<AvBreadcrumbItem[]>;
+    separator: _angular_core.InputSignal<string>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    itemSelected: _angular_core.OutputEmitterRef<AvBreadcrumbItem>;
+    get label(): string;
+    protected readonly role = "navigation";
+    isCurrent(item: AvBreadcrumbItem, index: number): boolean;
+    select(item: AvBreadcrumbItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvBreadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvBreadcrumb, "av-breadcrumb", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+type AvInputGroupRounded = number | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+declare class AvInputGroup {
+    private readonly config;
+    label: _angular_core.InputSignal<string>;
+    helper: _angular_core.InputSignal<string>;
+    errorMessage: _angular_core.InputSignal<string>;
+    prefixIcon: _angular_core.InputSignal<string>;
+    suffixIcon: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<string>;
+    rounded: _angular_core.InputSignal<AvInputGroupRounded>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hasError: _angular_core.Signal<boolean>;
+    get disabledClass(): boolean;
+    get invalidClass(): boolean;
+    get accent(): string;
+    get radius(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvInputGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvInputGroup, "av-input-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "helper": { "alias": "helper"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; "isSignal": true; }; "suffixIcon": { "alias": "suffixIcon"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["[prefix], [avInputPrefix], [av-input-prefix]", "*", "[suffix], [avInputSuffix], [av-input-suffix]", "[actions], [avInputActions], [av-input-actions]"], true, never>;
+}
+declare class AvInputGroupControl {
+    protected readonly controlClass = true;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvInputGroupControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AvInputGroupControl, "input[avInputGroupControl], textarea[avInputGroupControl], input[av-input-group-control], textarea[av-input-group-control]", never, {}, {}, never, never, true, never>;
+}
+
+type AvRadioGroupOrientation = 'horizontal' | 'vertical';
+type AvRadioValue = string | number | boolean | null;
+declare class AvRadioGroup implements ControlValueAccessor {
+    ngControl: NgControl;
+    private readonly config;
+    private readonly items;
+    label: _angular_core.InputSignal<string>;
+    helper: _angular_core.InputSignal<string>;
+    errorMessage: _angular_core.InputSignal<string>;
+    name: _angular_core.InputSignal<string>;
+    orientation: _angular_core.InputSignal<AvRadioGroupOrientation>;
+    variant: _angular_core.InputSignal<string>;
+    valueChange: _angular_core.OutputEmitterRef<AvRadioValue>;
+    changed: _angular_core.OutputEmitterRef<AvRadioValue>;
+    value: _angular_core.WritableSignal<AvRadioValue>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    onChange: (value: AvRadioValue) => void;
+    onTouched: () => void;
+    readonly hasError: _angular_core.Signal<boolean>;
+    get horizontalClass(): boolean;
+    get invalidClass(): boolean;
+    get accent(): string;
+    constructor(ngControl: NgControl);
+    register(item: AvRadio): void;
+    unregister(item: AvRadio): void;
+    select(value: AvRadioValue): void;
+    isSelected(value: AvRadioValue): boolean;
+    writeValue(value: AvRadioValue): void;
+    registerOnChange(fn: (value: AvRadioValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvRadioGroup, [{ optional: true; self: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvRadioGroup, "av-radio-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "helper": { "alias": "helper"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "changed": "changed"; }, never, ["*"], true, never>;
+}
+declare class AvRadio implements OnDestroy {
+    readonly group: AvRadioGroup | null;
+    value: _angular_core.InputSignal<AvRadioValue>;
+    label: _angular_core.InputSignal<string>;
+    description: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    get checkedClass(): boolean;
+    get disabledClass(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvRadio, "av-radio", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 type AvCalendarView = 'month' | 'year';
 type AvCalendarInputDate = Date | string | number;
 interface AvCalendarEvent<T = unknown> {
@@ -1151,6 +1676,9 @@ interface VisualsConfig {
 
 declare class ThemeService {
     private config;
+    private readonly destroyRef;
+    private readonly document;
+    private readonly isBrowser;
     private readonly colorIntensities;
     readonly mode: _angular_core.WritableSignal<AvThemeMode>;
     readonly systemDark: _angular_core.WritableSignal<boolean>;
@@ -1165,5 +1693,5 @@ declare class ThemeService {
 declare const VISUALS_CONFIG: InjectionToken<VisualsConfig>;
 declare function provideAngularVisuals(config: VisualsConfig): EnvironmentProviders;
 
-export { AvBadge, AvButton, AvCalendar, AvCard, AvCarousel, AvCarouselItem, AvCheckbox, AvCluster, AvCurrencyInput, AvDateTimePicker, AvDivider, AvDropdown, AvDropdownItem, AvFileUpload, AvForm, AvGrid, AvIcon, AvIconRegistry, AvInline, AvInput, AvMultiSelect, AvNavDropdown, AvNavLink, AvPaginator, AvProgressBar, AvProgressBarCircle, AvSelect, AvSidenav, AvSlider, AvStack, AvStep, AvStepper, AvSwitch, AvTab, AvTable, AvTabs, AvText, AvTextArea, AvTooltip, ThemeService, VISUALS_CONFIG, provideAngularVisuals };
-export type { AvCalendarDateSelect, AvCalendarEvent, AvCalendarEventSelect, AvCalendarInputDate, AvCalendarView, AvCardAppearance, AvCardPadding, AvCardRounded, AvDropdownPlacement, AvFileUploadFile, AvFileUploadRejection, AvFileUploadValue, AvRegisteredIcon, AvSidenavMode, AvSidenavTrigger, AvSliderRangeValue, AvSliderValue, AvTooltipPosition };
+export { AvAccordion, AvAccordionItem, AvAlert, AvAvatar, AvBadge, AvBottomnav, AvBox, AvBreadcrumb, AvButton, AvButtonGroup, AvButtonGroupItem, AvCalendar, AvCard, AvCarousel, AvCarouselItem, AvCenter, AvCheckbox, AvChip, AvCluster, AvCurrencyInput, AvDateTimePicker, AvDialog, AvDivider, AvDrawer, AvDropdown, AvDropdownItem, AvEmptyState, AvFileUpload, AvForm, AvGrid, AvHeading, AvIcon, AvIconRegistry, AvInline, AvInput, AvInputGroup, AvInputGroupControl, AvKbd, AvMultiSelect, AvNavDropdown, AvNavLink, AvPaginator, AvPopover, AvProgressBar, AvProgressBarCircle, AvRadio, AvRadioGroup, AvSelect, AvSidenav, AvSkeleton, AvSlider, AvSortableColumn, AvSpacer, AvStack, AvStep, AvStepper, AvSwitch, AvTab, AvTable, AvTabs, AvChip as AvTag, AvText, AvTextArea, AvTimeline, AvTimelineItem, AvToast, AvToastRef, AvTooltip, AvVisuallyHidden, ThemeService, ToastService, VISUALS_CONFIG, provideAngularVisuals };
+export type { AvAccordionVariant, AvAlertAppearance, AvAlertVariant, AvAvatarSize, AvBottomnavHighlight, AvBottomnavPosition, AvBoxPadding, AvBoxRounded, AvBoxSurface, AvBreadcrumbItem, AvButtonGroupOrientation, AvButtonGroupValue, AvCalendarDateSelect, AvCalendarEvent, AvCalendarEventSelect, AvCalendarInputDate, AvCalendarView, AvCardAppearance, AvCardPadding, AvCardRounded, AvChipAppearance, AvDialogRole, AvDrawerPlacement, AvDropdownPlacement, AvFileUploadFile, AvFileUploadRejection, AvFileUploadValue, AvHeadingAlign, AvInputGroupRounded, AvPopoverPlacement, AvRadioGroupOrientation, AvRadioValue, AvRegisteredIcon, AvSidenavMode, AvSidenavTrigger, AvSkeletonRounded, AvSliderRangeValue, AvSliderValue, AvSpacerAxis, AvTimelineDensity, AvTimelineSide, AvToastOptions, AvToastVariant, AvTooltipPosition, PageChangeEvent, SortEvent };