@almoamendev/ngx-md3 0.0.8

package/types/almoamendev-ngx-md3.d.ts

@@ -0,0 +1,1298 @@
+import * as _angular_core from '@angular/core';
+import { ViewContainerRef, Injector, ElementRef, AfterViewInit, OnDestroy, OnInit, Renderer2, Signal, InputSignal, AfterContentInit, Type, ComponentRef, InjectionToken, TemplateRef } from '@angular/core';
+import { FlexibleConnectedPositionStrategyOrigin, ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
+import * as i1 from '@angular/cdk/scrolling';
+import { AbstractControl } from '@angular/forms';
+import * as i1$1 from '@angular/router';
+import { Observable } from 'rxjs';
+import { CdkPortalOutlet } from '@angular/cdk/portal';
+
+type TextSize = 'large' | 'medium' | 'small';
+
+type TextColor = 'on-primary' | 'on-primary-container' | 'on-secondary' | 'on-secondary-container' | 'on-tertiary' | 'on-tertiary-container' | 'on-primary-fixed' | 'on-primary-fixed-variant' | 'on-secondary-fixed' | 'on-secondary-fixed-variant' | 'on-tertiary-fixed' | 'on-tertiary-fixed-variant' | 'on-error' | 'on-error-container' | 'on-surface' | 'on-surface-variant' | 'inverse-on-surface';
+
+type CardType = 'elevated' | 'filled' | 'outlined';
+
+type ButtonSize = 'x-small' | 'small' | 'medium' | 'large' | 'x-large';
+
+type ButtonType = 'elevated' | 'filled' | 'tonal' | 'outlined' | 'text';
+
+type IconButtonType = 'filled' | 'tonal' | 'outlined' | 'standard';
+
+type IconButtonWidth = 'default' | 'narrow' | 'wide';
+
+type SplitButtonType = 'elevated' | 'filled' | 'tonal' | 'outlined';
+
+type ButtonGroupType = 'standard' | 'connected';
+
+type ButtonGroupSelection = 'none' | 'single' | 'multiple';
+
+type FabSize = 'small' | 'medium' | 'large';
+
+type FabType = 'tonal-primary' | 'tonal-secondary' | 'tonal-tertiary' | 'primary' | 'secondary' | 'tertiary';
+
+type SliderSize = 'x-small' | 'small' | 'medium' | 'large' | 'x-large';
+
+type DialogRole = 'dialog' | 'alertdialog';
+
+type ChipType = 'assist' | 'filter' | 'input' | 'suggestion';
+
+type ChipStyle = 'default' | 'surface' | 'elevated';
+
+type ListLeadingType = 'icon' | 'avatar' | 'media' | 'selection-input';
+
+type ListLeadingSize = 'image' | 'small-video' | 'large-video';
+
+interface DialogConfig<D = unknown> {
+    /**
+     * Optional data passed to the component opened inside the dialog.
+     * The dynamic component can read it by injecting DIALOG_DATA.
+     */
+    data?: D;
+    /**
+     * When enabled, object keys from data are also assigned to matching inputs
+     * on the dynamic component through Angular's setInput API.
+     */
+    bindDataToInputs?: boolean;
+    disableCloseEvents?: boolean;
+    role?: DialogRole;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+    scheme?: 'inherit' | 'dark' | 'light';
+    direction?: null | 'ltr' | 'rtl';
+    /**
+     * Optional Angular context for the dynamic component. Passing a
+     * ViewContainerRef keeps dependency lookup close to the caller.
+     */
+    viewContainerRef?: ViewContainerRef;
+    injector?: Injector;
+}
+
+type MenuPositionX = 'start' | 'end' | 'before' | 'after' | 'center';
+type MenuPositionY = 'above' | 'below' | 'center';
+type MenuScrollStrategy = 'reposition' | 'block' | 'close' | 'noop';
+type MenuPositionOrigin = FlexibleConnectedPositionStrategyOrigin | MouseEvent;
+interface MenuConfig<D = unknown> {
+    /**
+     * Optional data passed to the component opened inside the menu.
+     * The dynamic component can read it by injecting MENU_DATA.
+     */
+    data?: D;
+    /**
+     * When enabled, object keys from data are also assigned to matching inputs
+     * on the dynamic component through Angular's setInput API.
+     */
+    bindDataToInputs?: boolean;
+    menuColors?: 'standard' | 'vibrant';
+    /**
+     * Element or point the menu should open from. If omitted, the service uses
+     * the currently focused element, which usually is the trigger button.
+     */
+    origin?: MenuPositionOrigin;
+    /**
+     * Horizontal alignment against the origin.
+     * start/end align edges, before/after place the menu beside the origin.
+     */
+    xPosition?: MenuPositionX;
+    /**
+     * Vertical alignment against the origin.
+     */
+    yPosition?: MenuPositionY;
+    /**
+     * Keep the menu on top of the trigger instead of opening outside it.
+     */
+    overlapTrigger?: boolean;
+    /**
+     * Additional pixel offsets from the resolved connected position.
+     */
+    offsetX?: number;
+    offsetY?: number;
+    /**
+     * Distance in pixels the menu should keep from the viewport edge.
+     * Values below 0.5em are raised to 0.5em.
+     */
+    viewportMargin?: number;
+    /**
+     * Custom CDK connected positions. When provided, these replace the default
+     * Material-style fallback positions.
+     */
+    positions?: ConnectedPosition[];
+    /**
+     * How the menu reacts when the page scrolls.
+     */
+    scrollStrategy?: MenuScrollStrategy;
+    /**
+     * Menu scheme colors
+     * @default inherit
+     */
+    scheme?: 'inherit' | 'dark' | 'light';
+    /**
+     * Menu direction. when null the direction will depends on default page direction.
+     * @default null
+     */
+    direction?: null | 'ltr' | 'rtl';
+    /**
+     * Optional Angular context for the dynamic component. Passing a
+     * ViewContainerRef keeps dependency lookup close to the caller.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /**
+     * Optional Angular injector used when creating the menu component.
+     */
+    injector?: Injector;
+}
+
+type SideSheetSide = 'start' | 'end';
+type SideSheetType = 'default' | 'standard' | 'modal';
+interface SideSheetConfig<D = unknown> {
+    data?: D;
+    bindDataToInputs?: boolean;
+    side?: SideSheetSide;
+    type?: SideSheetType;
+    inset?: boolean;
+    divider?: boolean;
+    closeExisting?: boolean;
+    viewContainerRef?: ViewContainerRef;
+    injector?: Injector;
+}
+interface SideSheetContainer {
+    element: HTMLElement;
+    showSheet(value: boolean): void;
+    setHidden(value: boolean): void;
+}
+
+type SnackbarPoliteness = 'polite' | 'assertive';
+interface SnackbarConfig<D = unknown> {
+    /**
+     * Context object passed to the message when it is a TemplateRef (read via
+     * NgTemplateOutlet's context). Ignored when the message is a plain string.
+     */
+    data?: D;
+    /**
+     * Shows a close (dismiss) icon instead of a text action. Material Design 3
+     * snackbars support only one or the other, never both — passing an
+     * actionLabel to SnackbarService.open() together with showCloseIcon: true
+     * throws, since that combination isn't a valid MD3 snackbar.
+     */
+    showCloseIcon?: boolean;
+    /**
+     * Stacks the action below the message on its own line, aligned to the
+     * inline-end, instead of placing it beside the message on one row. Use
+     * this when the action label is too long to comfortably share a line
+     * with the message — Material Design 3's "long action" snackbar layout.
+     * Has no effect when there's no actionLabel.
+     */
+    stackedAction?: boolean;
+    /**
+     * Called when the action button is clicked, right before the snackbar
+     * closes with reason 'action'. Only fires for the action button — never
+     * for the close icon, which always just dismisses. Equivalent to
+     * subscribing to SnackbarRef.onAction(), but handy when you don't want
+     * to hold onto the ref just to react to the click.
+     */
+    onAction?: () => void;
+    /**
+     * Auto-dismiss delay in milliseconds. Defaults to 4000. Pass 0 to disable
+     * auto-dismiss entirely — the snackbar then stays open until the action,
+     * the close icon, SnackbarRef.close(), or SnackbarService.dismiss() is
+     * used. Useful for progress/status snackbars driven by a TemplateRef.
+     */
+    duration?: number;
+    /**
+     * Controls aria-live politeness and the implicit role: 'polite' renders
+     * role="status" (announced without interrupting), 'assertive' renders
+     * role="alert" (announced immediately). Defaults to 'polite'.
+     */
+    politeness?: SnackbarPoliteness;
+    /**
+     * When true, immediately dismisses whatever snackbar is currently showing
+     * and moves this one to the front of the queue instead of waiting its
+     * turn behind already-queued snackbars.
+     */
+    replaceCurrent?: boolean;
+    ariaLabel?: string;
+    scheme?: 'inherit' | 'dark' | 'light';
+    direction?: null | 'ltr' | 'rtl';
+    position?: 'start' | 'center' | 'end';
+    /**
+     * Extra space, in pixels, to add below the snackbar on top of the
+     * automatic inset the scaffold already applies to clear a bottom
+     * navigation bar. Use this to clear your own fixed bottom elements —
+     * a custom bottom bar, a FAB, etc. — that the scaffold doesn't know
+     * about. Defaults to 0.
+     */
+    bottomOffset?: number;
+    /**
+     * Optional Angular context for the message TemplateRef.
+     */
+    viewContainerRef?: ViewContainerRef;
+    injector?: Injector;
+}
+
+declare class TypeDisplay {
+    el: ElementRef;
+    size: _angular_core.InputSignal<TextSize | "default">;
+    color: _angular_core.InputSignal<TextColor | "default">;
+    emphasized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TypeDisplay, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TypeDisplay, "md3-type-display, [md3-type-display]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emphasized": { "alias": "emphasized"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TypeHeadline {
+    el: ElementRef;
+    size: _angular_core.InputSignal<TextSize | "default">;
+    color: _angular_core.InputSignal<TextColor | "default">;
+    emphasized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TypeHeadline, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TypeHeadline, "md3-type-headline, [md3-type-headline]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emphasized": { "alias": "emphasized"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TypeTitle {
+    el: ElementRef;
+    size: _angular_core.InputSignal<TextSize | "default">;
+    color: _angular_core.InputSignal<TextColor | "default">;
+    emphasized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TypeTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TypeTitle, "md3-type-title, [md3-type-title]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emphasized": { "alias": "emphasized"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TypeBody {
+    el: ElementRef;
+    size: _angular_core.InputSignal<TextSize | "default">;
+    color: _angular_core.InputSignal<TextColor | "default">;
+    emphasized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TypeBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TypeBody, "md3-type-body, [md3-type-body]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emphasized": { "alias": "emphasized"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TypeLabel {
+    el: ElementRef;
+    size: _angular_core.InputSignal<TextSize | "default">;
+    color: _angular_core.InputSignal<TextColor | "default">;
+    emphasized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TypeLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TypeLabel, "md3-type-label, [md3-type-label]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emphasized": { "alias": "emphasized"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type ViewportWidth = 'compact' | 'medium' | 'expanded' | 'large' | 'extra-large';
+
+type ViewportHeight = 'compact' | 'medium' | 'expanded';
+
+type Md3NavigationMode = 'none' | 'navigation-bar' | 'navigation-rail' | 'standard-drawer' | 'modal-drawer';
+declare class LayoutService {
+    private readonly document;
+    private readonly breakpointObserver;
+    private readonly router;
+    private readonly widthQueries;
+    private readonly heightQueries;
+    private mainPaneSub?;
+    private mainPaneEl?;
+    private panesContainerResizeObserver?;
+    private panesContainerResizeListener?;
+    readonly mainScrollTop: _angular_core.WritableSignal<number>;
+    readonly mainIsScrolled: _angular_core.Signal<boolean>;
+    /**
+     * Distance, in pixels, between the viewport bottom and the bottom edge of
+     * the scaffold's .md3-panes-container — i.e. whatever the bottom scaffold
+     * bar (nav bar) currently reserves, or 0 when there is none. Overlay-based
+     * components anchored to the viewport bottom (like Snackbar) read this so
+     * they never render lower than the panes container.
+     */
+    readonly bottomInset: _angular_core.WritableSignal<number>;
+    readonly viewport: _angular_core.Signal<{
+        width: number;
+        height: number;
+    } | {
+        readonly width: number;
+        readonly height: number;
+    }>;
+    readonly widthClass: _angular_core.Signal<ViewportWidth>;
+    readonly heightClass: _angular_core.Signal<ViewportHeight>;
+    readonly direction: _angular_core.WritableSignal<"ltr" | "rtl">;
+    readonly isCompact: _angular_core.Signal<boolean>;
+    readonly isMedium: _angular_core.Signal<boolean>;
+    readonly isExpanded: _angular_core.Signal<boolean>;
+    readonly isLarge: _angular_core.Signal<boolean>;
+    readonly isExtraLarge: _angular_core.Signal<boolean>;
+    readonly isPortrait: _angular_core.Signal<boolean>;
+    readonly isLandscape: _angular_core.Signal<boolean>;
+    readonly preferredNavigationMode: _angular_core.Signal<"navigation-bar" | "navigation-rail" | "standard-drawer">;
+    darkMode: _angular_core.WritableSignal<boolean>;
+    constructor();
+    setDirection(direction: 'ltr' | 'rtl'): void;
+    private scrollMainPaneToTop;
+    registerMainPane(element: HTMLElement): void;
+    unregisterMainPane(element: HTMLElement): void;
+    registerPanesContainer(element: HTMLElement): void;
+    unregisterPanesContainer(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LayoutService>;
+}
+
+declare class Scaffold implements AfterViewInit, OnDestroy {
+    private startOutlet;
+    private endOutlet;
+    private panesContainer;
+    private sheets;
+    private layout;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Scaffold, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Scaffold, "md3-scaffold", never, {}, {}, never, ["[md3-scaffold-bar=top]", "[md3-scaffold-rail=leading]", "[md3-scaffold-pane=start]", "[md3-scaffold-pane=main]", "[md3-scaffold-pane=end]", "[md3-scaffold-rail=trailing]", "[md3-scaffold-bar=bottom]"], true, never>;
+}
+
+declare class ScaffoldBar {
+    region: _angular_core.InputSignal<"top" | "bottom">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScaffoldBar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScaffoldBar, "[md3-scaffold-bar]", never, { "region": { "alias": "md3-scaffold-bar"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScaffoldRail {
+    region: _angular_core.InputSignal<"leading" | "trailing">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScaffoldRail, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScaffoldRail, "[md3-scaffold-rail]", never, { "region": { "alias": "md3-scaffold-rail"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScaffoldPane implements OnDestroy {
+    private el;
+    private layout;
+    role: _angular_core.InputSignal<"start" | "end" | "main">;
+    constructor(el: ElementRef, layout: LayoutService);
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScaffoldPane, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScaffoldPane, "[md3-scaffold-pane]", never, { "role": { "alias": "md3-scaffold-pane"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+
+declare class Grid {
+    private readonly layout;
+    readonly cols: _angular_core.InputSignal<number | undefined>;
+    protected readonly columns: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Grid, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Grid, "md3-grid, [md3-grid]", never, { "cols": { "alias": "cols"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GridItem {
+    readonly colSpan: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly span: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridItem, "md3-grid-item, [md3-grid-item]", never, { "colSpan": { "alias": "col-span"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InputElement {
+    private el;
+    constructor(el: ElementRef<HTMLInputElement>);
+    get nativeElement(): HTMLInputElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputElement, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputElement, "[md3-input-element]", never, {}, {}, never, never, true, never>;
+}
+
+declare class StateComponent implements OnInit {
+    private el;
+    private renderer;
+    private stateLayer?;
+    private stateLayerSignal;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    private init;
+    setStateLayer(value: boolean): void;
+    private enable;
+    private disable;
+    onPointerDown(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StateComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StateComponent, "[md3-state-component]", never, {}, {}, never, never, true, never>;
+}
+
+declare class IconElement {
+    private el;
+    iconType: _angular_core.InputSignal<string | null>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconElement, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconElement, "[md3-icon-element]", never, { "iconType": { "alias": "md3-icon-element"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialIcon {
+    private el;
+    iconVersion: _angular_core.InputSignal<"MaterialIcons" | "MaterialSymbols">;
+    isFilled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    iconStyle: _angular_core.InputSignal<"outlined" | "normal" | "rounded" | "sharp" | "two-tone">;
+    iconSize: _angular_core.InputSignal<48 | 36 | 24 | 18>;
+    biDirectional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialIcon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialIcon, "md3-icon", never, { "iconVersion": { "alias": "icon-version"; "required": false; "isSignal": true; }; "isFilled": { "alias": "filled"; "required": false; "isSignal": true; }; "iconStyle": { "alias": "icon-style"; "required": false; "isSignal": true; }; "iconSize": { "alias": "icon-size"; "required": false; "isSignal": true; }; "biDirectional": { "alias": "bi-directional"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class Divider {
+    dividerType: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Divider, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Divider, "md3-divider", never, { "dividerType": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class Badge {
+    private el;
+    isSmall: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Badge, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Badge, "md3-badge", never, { "isSmall": { "alias": "small"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class Avatar {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Avatar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Avatar, "[md3-avatar]", never, {}, {}, never, never, true, [{ directive: typeof StateComponent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class Button {
+    private el;
+    private context;
+    onClick(event: Event): void;
+    buttonSize: _angular_core.InputSignal<ButtonSize>;
+    buttonType: _angular_core.InputSignal<ButtonType>;
+    isSquared: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isSelected: _angular_core.ModelSignal<boolean | null>;
+    effectiveSize: _angular_core.Signal<ButtonSize>;
+    effectiveType: _angular_core.Signal<"elevated" | "filled" | "outlined" | "tonal" | "text">;
+    effectiveSquared: _angular_core.Signal<boolean>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    enableSelection(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Button, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Button, "button[md3-button], a[md3-button]", never, { "buttonSize": { "alias": "button-size"; "required": false; "isSignal": true; }; "buttonType": { "alias": "button-type"; "required": false; "isSignal": true; }; "isSquared": { "alias": "button-squared"; "required": false; "isSignal": true; }; "isSelected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "isSelected": "selectedChange"; }, never, ["[md3-icon-element]", "*"], true, [{ directive: typeof StateComponent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class FloatingActionButton {
+    private el;
+    private context;
+    buttonSize: _angular_core.InputSignal<FabSize>;
+    buttonType: _angular_core.InputSignal<FabType>;
+    isExtended: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    effectiveSize: _angular_core.Signal<"large" | "medium" | "small" | "x-small" | "x-large">;
+    effectiveExtended: _angular_core.Signal<boolean>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingActionButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FloatingActionButton, "button[md3-fab], a[md3-fab]", never, { "buttonSize": { "alias": "button-size"; "required": false; "isSignal": true; }; "buttonType": { "alias": "button-type"; "required": false; "isSignal": true; }; "isExtended": { "alias": "extended"; "required": false; "isSignal": true; }; }, {}, never, ["[md3-icon-element]", "*"], true, [{ directive: typeof StateComponent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class IconButton {
+    private el;
+    private context;
+    onClick(event: Event): void;
+    buttonSize: _angular_core.InputSignal<ButtonSize>;
+    buttonType: _angular_core.InputSignal<IconButtonType>;
+    buttonWidth: _angular_core.InputSignal<IconButtonWidth>;
+    isSquared: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isSelected: _angular_core.ModelSignal<boolean | null>;
+    effectiveSize: _angular_core.Signal<ButtonSize>;
+    effectiveType: _angular_core.Signal<IconButtonType>;
+    effectiveWidth: _angular_core.Signal<IconButtonWidth>;
+    effectiveSquared: _angular_core.Signal<boolean>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    enableSelection(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconButton, "button[md3-icon-button], a[md3-icon-button]", never, { "buttonSize": { "alias": "button-size"; "required": false; "isSignal": true; }; "buttonType": { "alias": "button-type"; "required": false; "isSignal": true; }; "buttonWidth": { "alias": "button-width"; "required": false; "isSignal": true; }; "isSquared": { "alias": "button-squared"; "required": false; "isSignal": true; }; "isSelected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "isSelected": "selectedChange"; }, never, ["[md3-icon-element]", "*"], true, [{ directive: typeof StateComponent; inputs: {}; outputs: {}; }]>;
+}
+
+interface ButtonContext {
+    buttonContextSize?: Signal<ButtonSize>;
+    buttonContextType?: Signal<SplitButtonType>;
+    buttonContextWidth?: Signal<IconButtonWidth>;
+    buttonContextSquared?: Signal<boolean>;
+    buttonContextExtended?: Signal<boolean>;
+}
+
+declare class SplitButton implements ButtonContext {
+    private el;
+    buttonSize: _angular_core.InputSignal<ButtonSize>;
+    buttonType: _angular_core.InputSignal<SplitButtonType>;
+    flipTrailingIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private button;
+    private iconButtons;
+    buttonContextSize: Signal<ButtonSize>;
+    buttonContextType: Signal<SplitButtonType>;
+    buttonContextWidth: Signal<IconButtonWidth>;
+    buttonContextSquared?: Signal<boolean>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplitButton, "md3-split-button", never, { "buttonSize": { "alias": "button-size"; "required": false; "isSignal": true; }; "buttonType": { "alias": "button-type"; "required": false; "isSignal": true; }; "flipTrailingIcon": { "alias": "flip-trailing-icon"; "required": false; "isSignal": true; }; }, {}, ["button", "iconButtons"], ["button[md3-button], button[md3-icon-button][md3-main-action], a[md3-button], a[md3-icon-button][md3-main-action]", "button[md3-icon-button], a[md3-icon-button]"], true, never>;
+}
+
+declare class ButtonGroup implements ButtonContext {
+    private el;
+    onClick(event: PointerEvent): void;
+    buttonSize: InputSignal<ButtonSize>;
+    groupType: InputSignal<ButtonGroupType>;
+    groupSelection: InputSignal<ButtonGroupSelection>;
+    private buttons;
+    private iconButtons;
+    buttonContextSize: Signal<ButtonSize>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    private findEventButton;
+    private normalizeSingleSelection;
+    private clearOtherSelections;
+    private allButtons;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroup, "md3-button-group", never, { "buttonSize": { "alias": "button-size"; "required": false; "isSignal": true; }; "groupType": { "alias": "group-type"; "required": false; "isSignal": true; }; "groupSelection": { "alias": "selection"; "required": false; "isSignal": true; }; }, {}, ["buttons", "iconButtons"], ["button[md3-button], button[md3-icon-button], a[md3-button], a[md3-icon-button]"], true, never>;
+}
+
+declare class Card implements AfterViewInit {
+    private el;
+    private state;
+    cardType: _angular_core.InputSignal<CardType>;
+    isInteractive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private isActionTag;
+    constructor(el: ElementRef, state: StateComponent);
+    get element(): HTMLElement;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Card, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Card, "md3-card, button[md3-card], a[md3-card]", never, { "cardType": { "alias": "card-type"; "required": false; "isSignal": true; }; "isInteractive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof StateComponent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ChipAvatar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipAvatar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ChipAvatar, "[md3-chip-avatar]", never, {}, {}, never, never, true, never>;
+}
+declare class Chips {
+    private el;
+    chipType: _angular_core.InputSignal<ChipType>;
+    chipStyle: _angular_core.InputSignal<ChipStyle>;
+    trailingFunction: _angular_core.OutputEmitterRef<void>;
+    protected onTrailingClick(event: Event): void;
+    private avatar;
+    private iconElements;
+    hasSurface: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isElevated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    leading: _angular_core.Signal<IconElement | undefined>;
+    trailing: _angular_core.Signal<IconElement | undefined>;
+    isSelectable: _angular_core.Signal<boolean>;
+    showCheckIcon: _angular_core.Signal<boolean>;
+    hasAvatar: _angular_core.Signal<boolean>;
+    hasRemove: _angular_core.Signal<boolean>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Chips, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Chips, "button[md3-chip], a[md3-chip], label[md3-chip]", never, { "chipType": { "alias": "chip-type"; "required": false; "isSignal": true; }; "chipStyle": { "alias": "chip-style"; "required": false; "isSignal": true; }; "hasSurface": { "alias": "surface"; "required": false; "isSignal": true; }; "isElevated": { "alias": "elevated"; "required": false; "isSignal": true; }; }, { "trailingFunction": "on-trailing"; }, ["avatar", "iconElements"], ["[md3-input-element]", "[md3-icon-element=leading], [md3-chip-avatar]", "*", "[md3-icon-element=trailing]"], true, never>;
+}
+
+declare class Checkbox {
+    control: _angular_core.InputSignal<AbstractControl<any, any, any> | undefined>;
+    private stateComponent;
+    private input;
+    private controlName;
+    private controlError;
+    private nativeInputError;
+    disableStateLayer: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected checkboxIcon: 'check_small' | 'check_indeterminate_small';
+    state: _angular_core.WritableSignal<boolean | null>;
+    protected formControl: Signal<AbstractControl<any, any, any> | undefined>;
+    private inputError;
+    private inputDisabledState;
+    isDisabled: Signal<boolean>;
+    constructor();
+    private syncInitialState;
+    private updateState;
+    private syncStateFromInput;
+    private syncInputFromState;
+    private syncControlFromState;
+    private syncStateFromControl;
+    private syncNativeInputState;
+    private syncControlError;
+    private syncInputDisabledState;
+    private hasNativeInputError;
+    private hasControlError;
+    private syncAriaInvalidAttribute;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Checkbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Checkbox, "md3-checkbox", never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; "disableStateLayer": { "alias": "disable-state-layer"; "required": false; "isSignal": true; }; }, {}, ["input", "controlName"], ["[md3-input-element]"], true, never>;
+}
+
+declare class RadioButton {
+    control: _angular_core.InputSignal<AbstractControl<any, any, any> | undefined>;
+    private stateComponent;
+    private input;
+    private controlName;
+    private controlError;
+    private nativeInputError;
+    disableStateLayer: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    state: _angular_core.WritableSignal<boolean>;
+    protected formControl: _angular_core.Signal<AbstractControl<any, any, any> | undefined>;
+    private inputError;
+    private inputDisabledState;
+    isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    private syncInitialState;
+    private getInputValue;
+    private updateState;
+    private syncStateFromInput;
+    private syncInputFromState;
+    private syncControlFromInput;
+    private syncStateFromControl;
+    private isSameRadioGroup;
+    private syncNativeInputState;
+    private syncControlError;
+    private syncInputDisabledState;
+    private hasNativeInputError;
+    private hasControlError;
+    private syncAriaInvalidAttribute;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioButton, "md3-radio-button", never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; "disableStateLayer": { "alias": "disable-state-layer"; "required": false; "isSignal": true; }; }, {}, ["input", "controlName"], ["[md3-input-element]"], true, never>;
+}
+
+declare class Switch {
+    control: _angular_core.InputSignal<AbstractControl<any, any, any> | undefined>;
+    private stateComponent;
+    private input;
+    private controlName;
+    private controlError;
+    private nativeInputError;
+    disableStateLayer: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    state: _angular_core.WritableSignal<boolean>;
+    protected formControl: _angular_core.Signal<AbstractControl<any, any, any> | undefined>;
+    private inputError;
+    private inputDisabledState;
+    isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    private syncInitialState;
+    private updateState;
+    private syncStateFromInput;
+    private syncInputFromState;
+    private syncControlFromState;
+    private syncStateFromControl;
+    private syncNativeInputState;
+    private syncControlError;
+    private syncInputDisabledState;
+    private hasNativeInputError;
+    private hasControlError;
+    private syncAriaInvalidAttribute;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Switch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Switch, "md3-switch", never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; "disableStateLayer": { "alias": "disable-state-layer"; "required": false; "isSignal": true; }; }, {}, ["input", "controlName"], ["[md3-input-element]", "[md3-icon-element]"], true, never>;
+}
+
+declare class Slider {
+    private el;
+    control: _angular_core.InputSignal<AbstractControl<any, any, any> | undefined>;
+    sliderSize: _angular_core.InputSignal<SliderSize>;
+    showValueLabel: _angular_core.InputSignal<boolean>;
+    private input;
+    private controlName;
+    value: _angular_core.WritableSignal<number>;
+    min: _angular_core.WritableSignal<number>;
+    max: _angular_core.WritableSignal<number>;
+    progress: _angular_core.WritableSignal<number>;
+    protected formControl: _angular_core.Signal<AbstractControl<any, any, any> | undefined>;
+    constructor(el: ElementRef<HTMLElement>);
+    get element(): HTMLElement;
+    private syncInitialState;
+    private updateState;
+    private syncLimitsFromInput;
+    private syncStateFromInput;
+    private syncInputFromState;
+    private syncControlFromState;
+    private syncStateFromControl;
+    private syncInputDisabledState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Slider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Slider, "md3-slider", never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; "sliderSize": { "alias": "slider-size"; "required": false; "isSignal": true; }; "showValueLabel": { "alias": "show-value-label"; "required": false; "isSignal": true; }; }, {}, ["input", "controlName"], ["[md3-input-element]", "[md3-icon-element]"], true, never>;
+}
+
+declare class List {
+    private el;
+    variant: _angular_core.InputSignal<"expressive" | "baseline">;
+    type: _angular_core.InputSignal<"standard" | "segmented">;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<List, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<List, "md3-list", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ListItemPrimaryAction {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListItemPrimaryAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListItemPrimaryAction, "button[md3-item-primary-action], a[md3-item-primary-action]", never, {}, {}, never, never, true, [{ directive: typeof StateComponent; inputs: {}; outputs: {}; }]>;
+}
+declare class ListItem implements AfterViewInit {
+    private el;
+    private state;
+    slotsAlignment: _angular_core.InputSignal<"start" | "end" | "center">;
+    selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isActionTag: boolean;
+    private isLabelTag;
+    private checkbox;
+    private radioButton;
+    private switch;
+    isSelected: _angular_core.Signal<boolean>;
+    isInputDisabled: _angular_core.Signal<boolean | undefined>;
+    constructor(el: ElementRef, state: StateComponent);
+    get element(): HTMLElement;
+    ngAfterViewInit(): void;
+    protected onFocusIn(event: FocusEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    private setLabelInputTabIndex;
+    private getLabelActivationInput;
+    private getLabelInputs;
+    private focusLabel;
+    private isInputElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListItem, "md3-list-item, label[md3-list-item], button[md3-list-item], a[md3-list-item]", never, { "slotsAlignment": { "alias": "slots-alignment"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, {}, ["checkbox", "radioButton", "switch"], ["[md3-item-primary-action]", "md3-list-leading", "[md3-list-slot=content]", "[md3-list-slot=trailing]"], true, [{ directive: typeof StateComponent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ListLeading {
+    private el;
+    type: _angular_core.InputSignal<ListLeadingType>;
+    size: _angular_core.InputSignal<ListLeadingSize>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListLeading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListLeading, "md3-list-leading", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ListSlot {
+    private el;
+    position: _angular_core.InputSignal<"trailing" | "content">;
+    constructor(el: ElementRef);
+    get nativeElement(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListSlot, "[md3-list-slot]", never, { "position": { "alias": "md3-list-slot"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LoadingIndicator {
+    private el;
+    contained: _angular_core.InputSignal<boolean>;
+    size: _angular_core.InputSignal<number>;
+    dpSize: _angular_core.Signal<number>;
+    constructor(el: ElementRef);
+    get element(): HTMLElement;
+    private getHostFontSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingIndicator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoadingIndicator, "md3-loading-indicator", never, { "contained": { "alias": "contained"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LinearProgressIndicator {
+    indeterminate: _angular_core.InputSignal<boolean>;
+    thickness: _angular_core.InputSignal<4 | 8>;
+    progress: _angular_core.InputSignal<number>;
+    progressValue: _angular_core.Signal<number>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinearProgressIndicator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LinearProgressIndicator, "md3-linear-progress-indicator", never, { "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CircularProgressIndicator {
+    indeterminate: _angular_core.InputSignal<boolean>;
+    thickness: _angular_core.InputSignal<4 | 8>;
+    progress: _angular_core.InputSignal<number>;
+    progressValue: _angular_core.Signal<number>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CircularProgressIndicator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CircularProgressIndicator, "md3-circular-progress-indicator", never, { "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AppBarType = 'small' | 'medium' | 'large' | 'search';
+type AppBarScrollingStyle = 'none' | 'transparent' | 'elevate';
+declare class AppBar implements ButtonContext {
+    private el;
+    private layoutService;
+    title: _angular_core.InputSignal<string | null>;
+    subtitle: _angular_core.InputSignal<string | null>;
+    appBarType: _angular_core.InputSignal<AppBarType>;
+    appBarScrollingStyle: _angular_core.InputSignal<AppBarScrollingStyle>;
+    autoHide: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    centerAligned: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private logo;
+    private avatar;
+    hasLogo: Signal<boolean>;
+    hasAvatar: Signal<boolean>;
+    mainIsScrolled: Signal<boolean>;
+    isScrollingDown: _angular_core.WritableSignal<boolean>;
+    private scrollPosition;
+    private bottomExpandedHeight;
+    private bottomCollapse;
+    buttonContextSize: Signal<ButtonSize>;
+    constructor(el: ElementRef, layoutService: LayoutService);
+    get element(): HTMLElement;
+    private getBottomOpacity;
+    private isBottomCollapsed;
+    private updateScrollDirection;
+    private hasCollapsibleBottom;
+    private getHostFontSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppBar, "md3-app-bar", never, { "title": { "alias": "bar-title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "bar-subtitle"; "required": false; "isSignal": true; }; "appBarType": { "alias": "bar-type"; "required": false; "isSignal": true; }; "appBarScrollingStyle": { "alias": "scroll-style"; "required": false; "isSignal": true; }; "autoHide": { "alias": "auto-hide"; "required": false; "isSignal": true; }; "centerAligned": { "alias": "center-aligned"; "required": false; "isSignal": true; }; }, {}, ["logo", "avatar"], ["[md3-app-bar-leading]", "[md3-search-leading]", "[md3-input-element]", "[md3-search-trailing]", "[md3-app-bar-logo]", "[md3-app-bar-trailing]", "[md3-avatar]"], true, never>;
+}
+
+declare class AppBarLogo {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppBarLogo, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AppBarLogo, "[md3-app-bar-logo]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NavigationItem {
+    private readonly el;
+    private routerLinkActive;
+    hideOnCollapse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private icons;
+    hasIcons: _angular_core.Signal<boolean>;
+    badge: _angular_core.Signal<Badge | undefined>;
+    get isRouteActive(): boolean;
+    get active(): boolean;
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationItem, "button[md3-nav-item], a[md3-nav-item]", ["md3NavItem"], { "hideOnCollapse": { "alias": "hide-on-collapse"; "required": false; "isSignal": true; }; }, {}, ["icons", "badge"], ["[md3-icon-element=active]", "[md3-icon-element]", "*", "md3-badge"], true, [{ directive: typeof i1$1.RouterLinkActive; inputs: { "routerLinkActiveOptions": "routerLinkActiveOptions"; "ariaCurrentWhenActive": "ariaCurrentWhenActive"; }; outputs: {}; }]>;
+}
+
+declare class NavigationGroup {
+    private readonly el;
+    label: _angular_core.InputSignal<string | undefined>;
+    hideOnCollapse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationGroup, "md3-nav-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hideOnCollapse": { "alias": "hide-on-collapse"; "required": false; "isSignal": true; }; }, {}, never, ["[md3-nav-item]"], true, never>;
+}
+
+type ExpandedLayout = 'standard' | 'modal';
+type CollapsedLayout = 'compact' | 'narrow' | 'hidden';
+type ContainerStyle = 'none' | 'elevated' | 'divider';
+declare class NavigationRail implements ButtonContext {
+    private readonly el;
+    private readonly layoutService;
+    expanded: _angular_core.ModelSignal<boolean>;
+    hideMenuButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    fullWidthIndicator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    containerStyle: _angular_core.InputSignal<ContainerStyle>;
+    collapsedMode: _angular_core.InputSignal<CollapsedLayout>;
+    expandedMode: _angular_core.InputSignal<ExpandedLayout>;
+    private readonly resolvedCollapsedLayout;
+    private readonly resolvedExpandedLayout;
+    private menuIcons;
+    private floatingActionButton;
+    menuExpandIcon: Signal<IconElement | undefined>;
+    menuCollapseIcon: Signal<IconElement | undefined>;
+    hasFab: Signal<boolean>;
+    buttonContextSize: Signal<ButtonSize>;
+    buttonContextExtended: Signal<boolean>;
+    constructor();
+    get element(): HTMLElement;
+    toggle(): void;
+    collapse(): void;
+    expand(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationRail, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationRail, "md3-navigation-rail", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "hideMenuButton": { "alias": "hide-menu-button"; "required": false; "isSignal": true; }; "fullWidthIndicator": { "alias": "full-width-indicator"; "required": false; "isSignal": true; }; "containerStyle": { "alias": "container-style"; "required": false; "isSignal": true; }; "collapsedMode": { "alias": "collapsed-layout"; "required": false; "isSignal": true; }; "expandedMode": { "alias": "expanded-layout"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, ["menuIcons", "floatingActionButton"], ["[md3-icon-element=expand]", "[md3-icon-element=collapse]", "[md3-fab]", "[md3-nav-item], md3-nav-group"], true, never>;
+}
+
+declare class NavigationBar {
+    private readonly el;
+    private readonly layoutService;
+    private readonly resolvedLayout;
+    constructor();
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationBar, "md3-navigation-bar", never, {}, {}, never, ["[md3-nav-item]"], true, never>;
+}
+
+declare class TextField implements ButtonContext {
+    label: _angular_core.InputSignal<string | null>;
+    fieldType: _angular_core.InputSignal<"filled" | "outlined">;
+    inputCounter: _angular_core.InputSignal<number | boolean>;
+    control: _angular_core.InputSignal<AbstractControl<any, any, any> | undefined>;
+    private inputContainer;
+    private input;
+    private iconElements;
+    private iconButtons;
+    private controlName;
+    private controlError;
+    private nativeInputError;
+    private lastSyncedAriaInvalid;
+    formControl: Signal<AbstractControl<any, any, any> | undefined>;
+    inputError: Signal<boolean>;
+    maxLength: Signal<number | undefined>;
+    valueLength: _angular_core.WritableSignal<number>;
+    buttonContextSize: Signal<ButtonSize>;
+    constructor();
+    private syncNativeInputState;
+    private syncControlError;
+    private hasNativeInputError;
+    private hasControlError;
+    private syncAriaInvalidAttribute;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextField, "md3-text-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "fieldType": { "alias": "field-type"; "required": false; "isSignal": true; }; "inputCounter": { "alias": "input-counter"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; }, {}, ["input", "iconElements", "iconButtons", "controlName"], ["*", "[md3-icon-element=leading]", "[md3-icon-button], [md3-icon-element=trailing]", "[md3-supporting-text]"], true, never>;
+}
+
+declare class SupportingText {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SupportingText, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SupportingText, "[md3-supporting-text]", never, {}, {}, never, never, true, never>;
+}
+
+declare class Dialog implements AfterContentInit {
+    private readonly portalOutlet;
+    isActive: _angular_core.WritableSignal<boolean>;
+    protected readonly config: DialogConfig<unknown>;
+    protected get role(): string;
+    ngAfterContentInit(): void;
+    /**
+     * The service creates this wrapper first, then calls this method to mount
+     * the user supplied component into the dialog container.
+     */
+    attachContent<T>(component: Type<T>, injector: Injector): ComponentRef<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dialog, "md3-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare const DIALOG_DATA: InjectionToken<unknown>;
+declare const DIALOG_CONFIG: InjectionToken<DialogConfig<unknown>>;
+declare const DIALOG_COMPONENT: InjectionToken<Type<unknown>>;
+declare class DialogRef<T = unknown, R = unknown> {
+    private readonly overlayRef;
+    private readonly previouslyFocusedElement;
+    private readonly closed;
+    private isClosed;
+    dialogInstance?: Dialog;
+    /**
+     * Filled by DialogService after the user component is attached. Keeping the
+     * instance here lets callers imperatively update inputs when that is useful.
+     */
+    componentInstance?: T;
+    constructor(overlayRef: OverlayRef, previouslyFocusedElement: HTMLElement | null);
+    close(result?: R): void;
+    private startCloseAnimation;
+    afterClosed(): Observable<R | undefined>;
+}
+
+declare class DialogService {
+    private readonly overlay;
+    private readonly injector;
+    private readonly document;
+    open<T, D = unknown, R = unknown>(component: Type<T>, config?: DialogConfig<D>): DialogRef<T, R>;
+    private mergeConfig;
+    private createOverlay;
+    private startOpenAnimation;
+    private createInjector;
+    private bindDataToInputs;
+    private connectCloseEvents;
+    private focusDialog;
+    private getFocusedElement;
+    private canBindDataToInputs;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogService>;
+}
+
+declare class DialogHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogHeader, "md3-dialog-header", never, {}, {}, never, ["[md3-icon-element]", "*"], true, never>;
+}
+
+declare class DialogBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogBody, "md3-dialog-body", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class DialogActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogActions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogActions, "md3-dialog-actions", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class Menu implements AfterContentInit {
+    private el;
+    private readonly portalOutlet;
+    protected readonly config: MenuConfig<unknown>;
+    protected menuColors: _angular_core.WritableSignal<"standard" | "vibrant">;
+    protected isVisible: _angular_core.WritableSignal<boolean>;
+    protected scheme: _angular_core.WritableSignal<"inherit" | "dark" | "light">;
+    protected direction: _angular_core.WritableSignal<"ltr" | "rtl" | null>;
+    isActive: _angular_core.WritableSignal<boolean>;
+    get element(): HTMLElement;
+    constructor(el: ElementRef);
+    ngAfterContentInit(): void;
+    showMenu(value: boolean): void;
+    /**
+     * The service creates this wrapper first, then calls this method to mount
+     * the user supplied component into the dialog container.
+     */
+    attachContent<T>(component: Type<T>, injector: Injector): ComponentRef<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Menu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Menu, "md3-menu", never, {}, {}, never, never, true, never>;
+}
+
+declare const MENU_DATA: InjectionToken<unknown>;
+declare const MENU_CONFIG: InjectionToken<MenuConfig<unknown>>;
+declare const MENU_COMPONENT: InjectionToken<Type<unknown>>;
+declare class MenuRef<T = unknown, R = unknown> {
+    private readonly overlayRef;
+    private readonly previouslyFocusedElement;
+    private readonly closed;
+    private isClosed;
+    menuInstance?: Menu;
+    /**
+     * Filled by MenuService after the user component is attached. Keeping the
+     * instance here lets callers imperatively update inputs when that is useful.
+     */
+    componentInstance?: T;
+    constructor(overlayRef: OverlayRef, previouslyFocusedElement: HTMLElement | null);
+    close(result?: R): void;
+    private startCloseAnimation;
+    afterClosed(): Observable<R | undefined>;
+}
+
+declare class MenuService {
+    private readonly overlay;
+    private readonly injector;
+    private readonly document;
+    open<T, D = unknown, R = unknown>(component: Type<T>, config?: MenuConfig<D>): MenuRef<T, R>;
+    openSubMenu<T, D = unknown, R = unknown>(component: Type<T>, config?: MenuConfig<D>): MenuRef<T, R>;
+    private mergeConfig;
+    private createOverlay;
+    private bindTriggerActiveState;
+    private resolveOrigin;
+    private resolveTriggerElement;
+    private flipPositionIfPushBreaksAnchor;
+    private getInitialConnectedPositions;
+    private getPreferredConnectedPosition;
+    private getFallbackPositionAfterPush;
+    private shouldFlipXPosition;
+    private shouldFlipYPosition;
+    private createConnectedPosition;
+    private createSubMenuConnectedPosition;
+    private getHorizontalPosition;
+    private getVerticalPosition;
+    private getFallbackXPosition;
+    private getSubMenuXPosition;
+    private getFallbackYPosition;
+    private getSubMenuVerticalAlignment;
+    private getOriginClientRect;
+    private getViewportMargin;
+    private getHalfEmInPixels;
+    private getOffsetY;
+    private getSubMenuOffsetX;
+    private getSubMenuOffsetY;
+    private getScrollStrategy;
+    private isMouseEvent;
+    private isElementRef;
+    private startOpenAnimation;
+    private createInjector;
+    private bindDataToInputs;
+    private connectCloseEvents;
+    private getFocusedElement;
+    private canBindDataToInputs;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuService>;
+}
+
+declare class MenuGroup {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuGroup, "md3-menu-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MenuItem {
+    private el;
+    label: _angular_core.InputSignal<string>;
+    supportingText: _angular_core.InputSignal<string | null>;
+    trailingText: _angular_core.InputSignal<string | null>;
+    selected: _angular_core.ModelSignal<boolean | null>;
+    private iconElements;
+    get leading(): IconElement | undefined;
+    get trailing(): IconElement | undefined;
+    get showLeadingIcon(): boolean;
+    onHostClick(): void;
+    constructor(el: ElementRef<HTMLElement>);
+    get element(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItem, "button[md3-menu-item], a[md3-menu-item]", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "supportingText": { "alias": "supporting-text"; "required": false; "isSignal": true; }; "trailingText": { "alias": "trailing-text"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, ["iconElements"], ["[md3-icon-element=leading]", "md3-badge", "[md3-icon-element=trailing]"], true, never>;
+}
+
+declare class SideSheet implements AfterContentInit {
+    private layoutService;
+    private el;
+    private readonly portalOutlet;
+    protected readonly config: SideSheetConfig<unknown>;
+    private readonly sideSheetRef;
+    readonly isActive: _angular_core.WritableSignal<boolean>;
+    readonly isHidden: _angular_core.WritableSignal<boolean>;
+    readonly side: _angular_core.WritableSignal<SideSheetSide>;
+    readonly sheetType: _angular_core.WritableSignal<SideSheetType>;
+    readonly isInset: _angular_core.WritableSignal<boolean>;
+    readonly showDivider: _angular_core.WritableSignal<boolean>;
+    private readonly resolvedSheetType;
+    constructor(layoutService: LayoutService, el: ElementRef<HTMLElement>);
+    get element(): HTMLElement;
+    ngAfterContentInit(): void;
+    showSheet(value: boolean): void;
+    setHidden(value: boolean): void;
+    close(): void;
+    attachContent<T>(component: Type<T>, injector: Injector): ComponentRef<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SideSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SideSheet, "md3-side-sheet", never, {}, {}, never, never, true, never>;
+}
+
+declare const SIDE_SHEET_DATA: InjectionToken<unknown>;
+declare const SIDE_SHEET_CONFIG: InjectionToken<SideSheetConfig<unknown>>;
+declare const SIDE_SHEET_COMPONENT: InjectionToken<Type<unknown>>;
+declare class SideSheetRef<T = unknown, R = unknown> {
+    readonly side: SideSheetSide;
+    private readonly onClosed;
+    private readonly closed;
+    private isClosed;
+    private isHidden;
+    private sheetComponentRef?;
+    componentInstance?: T;
+    sheetInstance?: SideSheetContainer;
+    constructor(side: SideSheetSide, onClosed: () => void);
+    attachSheetComponentRef(sheetComponentRef: ComponentRef<SideSheet>): void;
+    setSide(side: SideSheetSide): void;
+    setSheetType(type: SideSheetType): void;
+    setInset(isInset: boolean): void;
+    setDivider(showDivider: boolean): void;
+    hide(): void;
+    show(): void;
+    close(result?: R): void;
+    dispose(result?: R): void;
+    afterClosed(): Observable<R | undefined>;
+    private destroySheet;
+    private startCloseAnimation;
+}
+
+declare class SheetsService {
+    private readonly injector;
+    private readonly states;
+    registerSideSheetOutlet(side: SideSheetSide, outlet: CdkPortalOutlet): void;
+    unregisterSideSheetOutlet(side: SideSheetSide, outlet: CdkPortalOutlet): void;
+    openSideSheet<T = unknown, D = unknown, R = unknown>(component: Type<T>, config?: SideSheetConfig<D>): SideSheetRef<T, R>;
+    closeSideSheet<R = unknown>(side?: SideSheetSide, result?: R): void;
+    private mergeConfig;
+    private createInjector;
+    private bindDataToInputs;
+    private canBindDataToInputs;
+    private disposeOutletState;
+    private disposeSideSheetRefs;
+    private removeSideSheetRef;
+    private getVisibleRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SheetsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SheetsService>;
+}
+
+declare class SideSheetHeader implements ButtonContext {
+    title: _angular_core.InputSignal<string>;
+    buttonContextSize: Signal<ButtonSize>;
+    buttonContextWidth: Signal<IconButtonWidth>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SideSheetHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SideSheetHeader, "md3-side-sheet-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["[md3-icon-button][leading]", "[md3-icon-button][trailing]"], true, never>;
+}
+
+declare class SideSheetBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SideSheetBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SideSheetBody, "md3-side-sheet-body", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SideSheetActions {
+    showDivider: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SideSheetActions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SideSheetActions, "md3-side-sheet-actions", never, { "showDivider": { "alias": "show-divider"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class Snackbar implements OnInit, OnDestroy {
+    private readonly el;
+    private readonly snackbarRef;
+    private readonly layout;
+    isActive: _angular_core.WritableSignal<boolean>;
+    protected readonly config: SnackbarConfig<unknown>;
+    protected readonly message: string | TemplateRef<unknown>;
+    protected readonly actionLabel: string | null | undefined;
+    protected get role(): string;
+    protected get isTemplateMessage(): boolean;
+    protected get templateMessage(): TemplateRef<unknown>;
+    protected get textMessage(): string;
+    protected get templateContext(): unknown;
+    protected get isStacked(): boolean;
+    constructor(el: ElementRef<HTMLElement>);
+    protected onInteractionStart(): void;
+    protected onInteractionEnd(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onActionClick(): void;
+    protected onCloseClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Snackbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Snackbar, "md3-snackbar", never, {}, {}, never, never, true, never>;
+}
+
+declare const SNACKBAR_MESSAGE: InjectionToken<string | TemplateRef<unknown>>;
+declare const SNACKBAR_ACTION_LABEL: InjectionToken<string | undefined>;
+declare const SNACKBAR_CONFIG: InjectionToken<SnackbarConfig<unknown>>;
+type SnackbarDismissReason = 'timeout' | 'action' | 'manual';
+interface SnackbarDismiss<R = unknown> {
+    reason: SnackbarDismissReason;
+    result?: R;
+}
+declare class SnackbarRef<R = unknown> {
+    private readonly duration;
+    private readonly closed;
+    private readonly actionTriggered;
+    private isClosed;
+    private overlayRef?;
+    private timeoutId?;
+    private timerStartedAt;
+    private remainingMs;
+    snackbarInstance?: Snackbar;
+    constructor(duration: number);
+    /**
+     * Called by SnackbarService once this snackbar is dequeued and actually
+     * attached to the overlay. Queued-but-never-shown refs never get one, and
+     * close() below handles that case without trying to animate or dispose.
+     */
+    attachOverlay(overlayRef: OverlayRef): void;
+    startTimer(): void;
+    pauseTimer(): void;
+    resumeTimer(): void;
+    triggerAction(result?: R): void;
+    close(reason?: SnackbarDismissReason, result?: R): void;
+    onAction(): Observable<void>;
+    afterDismissed(): Observable<SnackbarDismiss<R>>;
+    private startCloseAnimation;
+}
+
+declare class SnackbarService {
+    private readonly overlay;
+    private readonly injector;
+    private readonly queue;
+    private active?;
+    /**
+     * Opens a snackbar. Only one is ever visible at a time — if another is
+     * already showing, this one waits in a FIFO queue unless
+     * config.replaceCurrent is set.
+     *
+     * message can be a plain string, or a TemplateRef for cases like a
+     * progress indicator that needs to keep re-rendering as the caller's own
+     * state changes. The surrounding surface, action button, close icon,
+     * positioning, and animation are always owned by the Snackbar shell —
+     * there's no arbitrary custom-component API, since that's how you end up
+     * with something that isn't a snackbar anymore per MD3.
+     *
+     * config.onAction, if provided, is called when the action button (never
+     * the close icon) is clicked — an alternative to ref.onAction().subscribe()
+     * for callers that don't want to hold onto the returned ref.
+     */
+    open<D = unknown, R = unknown>(message: string | TemplateRef<D>, actionLabel?: string, config?: SnackbarConfig<D>): SnackbarRef<R>;
+    /** Dismisses whichever snackbar is currently showing, if any. */
+    dismiss<R = unknown>(result?: R): void;
+    /** Dismisses the visible snackbar and clears everything still queued. */
+    dismissAll(): void;
+    private show;
+    private onDismissed;
+    private mergeConfig;
+    private createOverlay;
+    private createInjector;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SnackbarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SnackbarService>;
+}
+
+export { AppBar, AppBarLogo, Avatar, Badge, Button, ButtonGroup, Card, Checkbox, ChipAvatar, Chips, CircularProgressIndicator, DIALOG_COMPONENT, DIALOG_CONFIG, DIALOG_DATA, Dialog, DialogActions, DialogBody, DialogHeader, DialogRef, DialogService, Divider, FloatingActionButton, Grid, GridItem, IconButton, IconElement, InputElement, LayoutService, LinearProgressIndicator, List, ListItem, ListItemPrimaryAction, ListLeading, ListSlot, LoadingIndicator, MENU_COMPONENT, MENU_CONFIG, MENU_DATA, MaterialIcon, Menu, MenuGroup, MenuItem, MenuRef, MenuService, NavigationBar, NavigationGroup, NavigationItem, NavigationRail, RadioButton, SIDE_SHEET_COMPONENT, SIDE_SHEET_CONFIG, SIDE_SHEET_DATA, SNACKBAR_ACTION_LABEL, SNACKBAR_CONFIG, SNACKBAR_MESSAGE, Scaffold, ScaffoldBar, ScaffoldPane, ScaffoldRail, SheetsService, SideSheetActions, SideSheetBody, SideSheetHeader, SideSheetRef, Slider, Snackbar, SnackbarRef, SnackbarService, SplitButton, StateComponent, SupportingText, Switch, TextField, TypeBody, TypeDisplay, TypeHeadline, TypeLabel, TypeTitle };
+export type { AppBarScrollingStyle, AppBarType, ButtonGroupSelection, ButtonGroupType, ButtonSize, ButtonType, CardType, ChipStyle, ChipType, DialogConfig, DialogRole, FabSize, FabType, IconButtonType, IconButtonWidth, ListLeadingSize, ListLeadingType, Md3NavigationMode, MenuConfig, MenuPositionOrigin, MenuPositionX, MenuPositionY, MenuScrollStrategy, SideSheetConfig, SideSheetContainer, SideSheetSide, SideSheetType, SliderSize, SnackbarConfig, SnackbarDismiss, SnackbarDismissReason, SnackbarPoliteness, SplitButtonType, TextColor, TextSize };