@vroxal/vd-angular 1.0.1

package/types/vroxal-vd-angular.d.ts

@@ -0,0 +1,1335 @@
+import * as i0 from '@angular/core';
+import { ElementRef, Renderer2, OnInit, EventEmitter, OnChanges, SimpleChanges, OnDestroy, TemplateRef, ViewContainerRef, ChangeDetectorRef, AfterViewInit } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { ControlValueAccessor } from '@angular/forms';
+import { Overlay, ScrollStrategyOptions } from '@angular/cdk/overlay';
+import { Router } from '@angular/router';
+import { DialogRef, Dialog } from '@angular/cdk/dialog';
+import * as i1 from '@angular/common';
+
+type ButtonVariant$1 = 'solid' | 'subtle' | 'outline' | 'transparent';
+type ButtonColor$1 = 'primary' | 'neutral' | 'error';
+type ButtonSize$1 = 'sm' | 'md' | 'lg';
+type IconSize$2 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type ButtonType = 'button' | 'submit' | 'reset';
+declare class VdButton {
+    private el;
+    private renderer;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    label: string;
+    variant?: ButtonVariant$1;
+    color?: ButtonColor$1;
+    size?: ButtonSize$1;
+    rounded?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    leftIcon?: string;
+    rightIcon?: string;
+    type: ButtonType;
+    /** Map button size → default icon size */
+    private buttonIconMap;
+    /** Effective icon size */
+    get effectiveIconSize(): IconSize$2;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdButton, "vd-button", never, { "label": { "alias": "label"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "rightIcon": { "alias": "rightIcon"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type IconSize$1 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare class VdIcon {
+    /** CSS class for the icon (e.g., "vd-icon-save") */
+    name: string;
+    size?: IconSize$1;
+    color?: string;
+    /** Compute CSS class for size */
+    get sizeClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdIcon, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdIcon, "vd-icon", never, { "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type ButtonVariant = 'solid' | 'subtle' | 'outline' | 'transparent';
+type ButtonColor = 'primary' | 'neutral' | 'error';
+type ButtonSize = 'sm' | 'md' | 'lg';
+type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare class VdIconButton {
+    private el;
+    private renderer;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    icon: string;
+    ariaLabel: string;
+    variant?: ButtonVariant;
+    color?: ButtonColor;
+    size?: ButtonSize;
+    rounded?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    private buttonIconMap;
+    /** Effective icon size */
+    get effectiveIconSize(): IconSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdIconButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdIconButton, "vd-icon-button", never, { "icon": { "alias": "icon"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type ToastColor = 'success' | 'error' | 'warning' | 'info';
+type ToastPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
+interface Toast {
+    id?: string;
+    color: ToastColor;
+    title?: string;
+    description: string;
+    icon?: string;
+    autoDismiss?: boolean;
+    isLeaving?: boolean;
+    timeoutId?: any;
+    remainingTime?: number;
+    startTime?: number;
+    position?: ToastPosition;
+}
+
+interface ToastConfig {
+    placement?: ToastPosition;
+    maxStack?: number;
+}
+declare class VdToastService {
+    private toasts;
+    private queue;
+    private subject;
+    toasts$: rxjs.Observable<Toast[]>;
+    private maxToasts;
+    private defaultPlacement;
+    /**
+     * Configure global toast settings
+     * @param config Configuration options for toasts
+     */
+    configure(config: ToastConfig): void;
+    /**
+     * Set the maximum number of toasts that can be displayed at once
+     * @param max Maximum number of toasts (default: 5)
+     */
+    setMaxToasts(max: number): void;
+    show(toast: Toast): void;
+    private startTimer;
+    pause(id: string): void;
+    resume(id: string): void;
+    dismiss(id: string): void;
+    private processQueue;
+    private emit;
+    private generateId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VdToastService>;
+}
+
+declare class VdToast implements OnInit {
+    toastService: VdToastService;
+    maxStack?: number;
+    positions: ToastPosition[];
+    constructor(toastService: VdToastService);
+    ngOnInit(): void;
+    get toastsByPosition$(): rxjs.Observable<Record<ToastPosition, Toast[]>>;
+    trackById(_: number, toast: Toast): string | undefined;
+    close(id: string): void;
+    onMouseEnter(toast: Toast): void;
+    onMouseLeave(toast: Toast): void;
+    getIconName(toast: Toast): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdToast, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdToast, "vd-toast", never, { "maxStack": { "alias": "maxStack"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VdInput {
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    leadingIcon?: string;
+    trailingActionIcon?: string;
+    placeholder: string;
+    type: 'text' | 'password';
+    value: string;
+    maxInputCount?: number;
+    readOnly?: boolean;
+    disabled?: boolean;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<string>;
+    valueCommit: EventEmitter<string>;
+    trailingActionClick: EventEmitter<void>;
+    inputFocus: EventEmitter<void>;
+    inputId: string;
+    showHint: boolean;
+    isFocused: boolean;
+    onFocus(): void;
+    inputElement: ElementRef<HTMLInputElement>;
+    focusInput(): void;
+    onBlur(): void;
+    onInput(event: Event): void;
+    onTrailingActionClick(): void;
+    toggleHint(): void;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    get trailingStateIcon(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdInput, "vd-input", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingActionIcon": { "alias": "trailingActionIcon"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxInputCount": { "alias": "maxInputCount"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "valueCommit": "valueCommit"; "trailingActionClick": "trailingActionClick"; "inputFocus": "inputFocus"; }, never, never, true, never>;
+}
+
+declare class VdCheckbox implements ControlValueAccessor, OnInit, OnChanges {
+    label?: string;
+    description?: string;
+    checked: boolean;
+    indeterminate: boolean;
+    disabled: boolean;
+    id?: string;
+    name?: string;
+    ariaLabel?: string;
+    change: EventEmitter<boolean>;
+    inputRef: ElementRef<HTMLInputElement>;
+    inputId: string;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onInputChange(event: Event): void;
+    onBlur(): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdCheckbox, "vd-checkbox", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+type VdCheckboxGroupDirection = 'vertical' | 'horizontal';
+interface VdCheckboxGroupItem {
+    label: string;
+    value?: string | number;
+    description?: string;
+    disabled?: boolean;
+    children?: VdCheckboxGroupItem[];
+}
+declare class VdCheckboxGroup implements OnChanges {
+    items: VdCheckboxGroupItem[];
+    direction: VdCheckboxGroupDirection;
+    value: Array<string | number>;
+    disabled: boolean;
+    valueChange: EventEmitter<(string | number)[]>;
+    private selectedValues;
+    ngOnChanges(changes: SimpleChanges): void;
+    onItemChange(item: VdCheckboxGroupItem, checked: boolean): void;
+    isChecked(item: VdCheckboxGroupItem): boolean;
+    isIndeterminate(item: VdCheckboxGroupItem): boolean;
+    trackByItem: (_: number, item: VdCheckboxGroupItem) => string | number;
+    private emitValueChange;
+    private syncSelectedValues;
+    private getSelectableValues;
+    private getAllLeafValues;
+    private getAllSelectableLeafValues;
+    private applyParentSelection;
+    private getItemValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdCheckboxGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdCheckboxGroup, "vd-checkbox-group", never, { "items": { "alias": "items"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+type TooltipPosition = 'top-center' | 'top-left' | 'top-right' | 'center-left' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+declare class VdTooltip {
+    text: string;
+    position: TooltipPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdTooltip, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdTooltip, "vd-tooltip", never, { "text": { "alias": "text"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type BadgeVariant = 'solid' | 'subtle';
+type BadgeColor = 'primary' | 'neutral' | 'error' | 'success' | 'info' | 'warning';
+type BadgeSize = 'sm' | 'md';
+declare class VdBadge {
+    label: string;
+    variant: BadgeVariant;
+    color: BadgeColor;
+    size: BadgeSize;
+    rounded: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdBadge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdBadge, "vd-badge", never, { "label": { "alias": "label"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VdDivider {
+    /** CSS class for the icon (e.g., "vd-icon-save") */
+    dashed?: boolean;
+    color?: string;
+    direction?: string;
+    inset?: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDivider, "vd-divider", never, { "dashed": { "alias": "dashed"; "required": false; }; "color": { "alias": "color"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "inset": { "alias": "inset"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VdPagination implements OnChanges {
+    totalPages: number;
+    currentPage: number;
+    pageChange: EventEmitter<number>;
+    pagesToShow: (number | '...')[];
+    ngOnChanges(): void;
+    private generatePages;
+    goToPage(page: number | '...'): void;
+    goPrevious(): void;
+    goNext(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdPagination, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdPagination, "vd-pagination", never, { "totalPages": { "alias": "totalPages"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+declare class VdDropdownService {
+    private openDropdownId$;
+    open(id: string): void;
+    close(id: string): void;
+    closeAll(): void;
+    changes(): rxjs.Observable<string | null>;
+    isOpen(id: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDropdownService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VdDropdownService>;
+}
+
+declare class VdDropdown implements OnInit, OnDestroy, OnChanges {
+    private overlay;
+    private vcr;
+    private dropdownService;
+    position: 'bottom-left' | 'bottom-center' | 'bottom-right' | 'top-left' | 'top-center' | 'top-right' | 'left-start' | 'right-start';
+    dropdownTemplate: TemplateRef<any>;
+    trigger: ElementRef<HTMLElement>;
+    private overlayRef?;
+    private destroy$;
+    private id;
+    constructor(overlay: Overlay, vcr: ViewContainerRef, dropdownService: VdDropdownService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDropdown, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDropdown, "vd-dropdown", never, { "position": { "alias": "position"; "required": false; }; }, {}, never, ["[vdDropdownTrigger]", "*"], true, never>;
+}
+
+interface VdDropdownControl {
+    close(): void;
+    id: string;
+}
+
+declare class VdDropdownItem {
+    private dropdown;
+    title: string;
+    description?: string;
+    icon?: string;
+    disabled: boolean;
+    select: EventEmitter<void>;
+    constructor(dropdown: VdDropdownControl | null);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDropdownItem, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDropdownItem, "vd-dropdown-item", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
+declare class VdDropdownItemLink {
+    href: string;
+    target?: string;
+    title: string;
+    disabled: boolean;
+    select: EventEmitter<Event>;
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDropdownItemLink, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDropdownItemLink, "vd-dropdown-item-link", never, { "href": { "alias": "href"; "required": false; }; "target": { "alias": "target"; "required": false; }; "title": { "alias": "title"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
+declare class VdDropdownItemGroup {
+    name?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDropdownItemGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDropdownItemGroup, "vd-dropdown-item-group", never, { "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class VdDropdownItemDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDropdownItemDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDropdownItemDivider, "vd-dropdown-item-divider", never, {}, {}, never, never, true, never>;
+}
+
+interface VdDatatableColumn<T = any> {
+    key: keyof T | string;
+    title: string;
+    cell?: (row: T) => string | number;
+    template?: TemplateRef<DatatableCellContext<T>>;
+}
+interface VdDatatableAction<T = any> {
+    title: string;
+    icon?: string;
+    action: (row: T) => void;
+    visible?: (row: T) => boolean;
+    disabled?: (row: T) => boolean;
+}
+interface DatatableCellContext<T> {
+    $implicit: T;
+    row: T;
+    key: keyof T | string;
+}
+declare class VdDatatable<T extends Record<string, any> = any> {
+    data: T[];
+    columns: VdDatatableColumn<T>[];
+    expandedColumns: VdDatatableColumn<T>[];
+    actions: VdDatatableAction<T>[];
+    currentPage: number;
+    totalPages: number;
+    rowsPerPage: number;
+    totalRows: number;
+    actionTriggered: EventEmitter<{
+        action: string;
+        row: T;
+    }>;
+    rowClicked: EventEmitter<T>;
+    pageChange: EventEmitter<number>;
+    expandedRow: T | null;
+    get isExpandable(): boolean;
+    get pagedData(): T[];
+    toggleExpand(row: T): void;
+    getRowActions(row: T): VdDatatableAction<T>[];
+    hasActions(row: T): boolean;
+    onActionClick(action: VdDatatableAction<T>, row: T): void;
+    onPageChanged(page: number): void;
+    get rangeStart(): number;
+    get rangeEnd(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDatatable<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDatatable<any>, "vd-datatable", never, { "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "expandedColumns": { "alias": "expandedColumns"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "totalPages": { "alias": "totalPages"; "required": false; }; "rowsPerPage": { "alias": "rowsPerPage"; "required": false; }; "totalRows": { "alias": "totalRows"; "required": false; }; }, { "actionTriggered": "actionTriggered"; "rowClicked": "rowClicked"; "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+type AccordionStyle = 'filled' | 'divided';
+declare class VdAccordion {
+    title: string;
+    variant: AccordionStyle;
+    icon?: string;
+    active: boolean;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdAccordion, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdAccordion, "vd-accordion", never, { "title": { "alias": "title"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class VdTextarea {
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    leadingIcon?: string;
+    trailingActionIcon?: string;
+    placeholder: string;
+    type: 'text' | 'password';
+    value: string;
+    maxInputCount?: number;
+    disabled?: boolean;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<string>;
+    valueCommit: EventEmitter<string>;
+    trailingActionClick: EventEmitter<void>;
+    inputFocus: EventEmitter<void>;
+    inputId: string;
+    showHint: boolean;
+    isFocused: boolean;
+    onFocus(): void;
+    onBlur(): void;
+    textareaElement: ElementRef<HTMLTextAreaElement>;
+    focusInput(): void;
+    onInput(event: Event): void;
+    onTrailingActionClick(): void;
+    toggleHint(): void;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    get trailingStateIcon(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdTextarea, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdTextarea, "vd-textarea", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingActionIcon": { "alias": "trailingActionIcon"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxInputCount": { "alias": "maxInputCount"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "valueCommit": "valueCommit"; "trailingActionClick": "trailingActionClick"; "inputFocus": "inputFocus"; }, never, never, true, never>;
+}
+
+interface VdSelectOption<T = any> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+declare class VdSelect<T = any> {
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    leadingIcon?: string;
+    placeholder: string;
+    disabled?: boolean;
+    options: VdSelectOption<T>[];
+    value: T | null;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<T | null>;
+    valueCommit: EventEmitter<T | null>;
+    inputFocus: EventEmitter<void>;
+    selectId: string;
+    isFocused: boolean;
+    onFocus(): void;
+    onBlur(): void;
+    selectElement: ElementRef<HTMLSelectElement>;
+    focusSelect(): void;
+    onChange(event: Event): void;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    get trailingStateIcon(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdSelect<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdSelect<any>, "vd-select", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "options": { "alias": "options"; "required": false; }; "value": { "alias": "value"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "valueCommit": "valueCommit"; "inputFocus": "inputFocus"; }, never, never, true, never>;
+}
+
+declare class VdSingleDatePicker implements OnChanges, OnDestroy {
+    private overlay;
+    private viewContainerRef;
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    placeholder: string;
+    disabled: boolean;
+    leadingIcon?: string;
+    showMonthYearSelector: boolean;
+    dropdownPosition: 'bottom-left' | 'bottom-center' | 'bottom-right' | 'top-left' | 'top-center' | 'top-right';
+    minDate?: Date;
+    maxDate?: Date;
+    value: Date | null;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<Date | null>;
+    inputFocus: EventEmitter<void>;
+    inputBlur: EventEmitter<void>;
+    isOpen: boolean;
+    isFocused: boolean;
+    trigger: ElementRef<HTMLElement>;
+    calendarPopupTemplate: TemplateRef<unknown>;
+    private overlayRef?;
+    private readonly onAnyScroll;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    get displayValue(): string;
+    private formatDate;
+    toggleCalendar(): void;
+    onInputFocus(): void;
+    onInputBlur(): void;
+    onDateSelect(date: Date | null): void;
+    ngOnDestroy(): void;
+    private openCalendar;
+    private closeCalendar;
+    private getPositionStrategy;
+    private getOverlayOriginElement;
+    private startScrollTracking;
+    private stopScrollTracking;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdSingleDatePicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdSingleDatePicker, "vd-single-date-picker", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "showMonthYearSelector": { "alias": "showMonthYearSelector"; "required": false; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "value": { "alias": "value"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "inputFocus": "inputFocus"; "inputBlur": "inputBlur"; }, never, never, true, never>;
+}
+
+interface DateRange {
+    start: Date | null;
+    end: Date | null;
+}
+declare class VdRangeDateInline implements OnInit {
+    value: DateRange | null;
+    minDate?: Date;
+    maxDate?: Date;
+    disabled: boolean;
+    valueChange: EventEmitter<DateRange | null>;
+    currentMonth: Date;
+    today: Date;
+    weekDays: string[];
+    months: string[];
+    calendarDays: Array<{
+        date: Date;
+        inMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isRangeStart: boolean;
+        isRangeEnd: boolean;
+        isInRange: boolean;
+        isDisabled: boolean;
+    }>;
+    nextMonthCalendarDays: Array<{
+        isDisabled: boolean;
+        date: Date;
+        inMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isRangeStart: boolean;
+        isRangeEnd: boolean;
+        isInRange: boolean;
+    }>;
+    ngOnInit(): void;
+    prevMonth(event?: Event): void;
+    nextMonth(event?: Event): void;
+    get currentMonthLabel(): string;
+    get nextMonthLabel(): string;
+    generateCalendar(): void;
+    private generateMonthCalendar;
+    createDayObject(date: Date, inMonth: boolean): {
+        date: Date;
+        inMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isRangeStart: boolean;
+        isRangeEnd: boolean;
+        isInRange: boolean;
+        isDisabled: boolean;
+    };
+    onDateClick(dayObj: any, event: Event): void;
+    isSameDay(d1: Date, d2: Date): boolean;
+    resetCalendarView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdRangeDateInline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdRangeDateInline, "vd-range-date-inline", never, { "value": { "alias": "value"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class VdRangeDatePicker implements OnChanges, OnDestroy {
+    private overlay;
+    private viewContainerRef;
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    placeholder: string;
+    disabled: boolean;
+    leadingIcon?: string;
+    dropdownPosition: 'bottom-left' | 'bottom-center' | 'bottom-right' | 'top-left' | 'top-center' | 'top-right';
+    minDate?: Date;
+    maxDate?: Date;
+    value: DateRange | null;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<DateRange | null>;
+    inputFocus: EventEmitter<void>;
+    inputBlur: EventEmitter<void>;
+    isOpen: boolean;
+    isFocused: boolean;
+    trigger: ElementRef<HTMLElement>;
+    calendarPopupTemplate: TemplateRef<unknown>;
+    private overlayRef?;
+    private readonly onAnyScroll;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    get displayValue(): string;
+    private formatDate;
+    toggleCalendar(): void;
+    onInputFocus(): void;
+    onInputBlur(): void;
+    onDateSelect(range: DateRange | null): void;
+    ngOnDestroy(): void;
+    private openCalendar;
+    private closeCalendar;
+    private getPositionStrategy;
+    private getOverlayOriginElement;
+    private startScrollTracking;
+    private stopScrollTracking;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdRangeDatePicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdRangeDatePicker, "vd-range-date-picker", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "value": { "alias": "value"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "inputFocus": "inputFocus"; "inputBlur": "inputBlur"; }, never, never, true, never>;
+}
+
+declare class VdTimePicker {
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    leadingIcon?: string;
+    trailingActionIcon?: string;
+    placeholder: string;
+    type: 'text' | 'password';
+    value: string;
+    maxInputCount?: number;
+    disabled?: boolean;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<string>;
+    valueCommit: EventEmitter<string>;
+    trailingActionClick: EventEmitter<void>;
+    inputFocus: EventEmitter<void>;
+    showHint: boolean;
+    isFocused: boolean;
+    onFocus(): void;
+    inputElement: ElementRef<HTMLInputElement>;
+    focusInput(): void;
+    openTimePicker(): void;
+    onBlur(): void;
+    onInput(event: Event): void;
+    onTrailingActionClick(): void;
+    onInputFocus(): void;
+    onInputBlur(): void;
+    toggleHint(): void;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdTimePicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdTimePicker, "vd-time-picker", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingActionIcon": { "alias": "trailingActionIcon"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxInputCount": { "alias": "maxInputCount"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "valueCommit": "valueCommit"; "trailingActionClick": "trailingActionClick"; "inputFocus": "inputFocus"; }, never, never, true, never>;
+}
+
+declare class VdDateTimePicker implements OnInit, OnChanges, OnDestroy {
+    private overlay;
+    private viewContainerRef;
+    mode: 'single' | 'range';
+    withTime: boolean;
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    placeholder: string;
+    disabled: boolean;
+    leadingIcon?: string;
+    showMonthYearSelector: boolean;
+    dropdownPosition: 'bottom-left' | 'bottom-center' | 'bottom-right' | 'top-left' | 'top-center' | 'top-right';
+    minDate?: Date;
+    maxDate?: Date;
+    value: Date | {
+        start: Date | null;
+        end: Date | null;
+    } | null;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<Date | {
+        start: Date | null;
+        end: Date | null;
+    } | null>;
+    inputFocus: EventEmitter<void>;
+    inputBlur: EventEmitter<void>;
+    isOpen: boolean;
+    isFocused: boolean;
+    trigger: ElementRef<HTMLElement>;
+    calendarPopupTemplate: TemplateRef<unknown>;
+    private overlayRef?;
+    private readonly onAnyScroll;
+    timeValue: string;
+    startTimeValue: string;
+    endTimeValue: string;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private extractTimeFromValue;
+    private formatTime;
+    private applyTimeToDate;
+    get displayValue(): string;
+    private formatDate;
+    toggleCalendar(): void;
+    onInputFocus(): void;
+    onInputBlur(): void;
+    onDateChange(newDate: Date | DateRange | null): void;
+    onTimeChange(timeStr: string): void;
+    onTimeCommit(timeStr: string): void;
+    onStartTimeChange(timeStr: string): void;
+    onStartTimeCommit(timeStr: string): void;
+    onEndTimeChange(timeStr: string): void;
+    onEndTimeCommit(timeStr: string): void;
+    private emitValue;
+    get singleDateValue(): Date | null;
+    get rangeDateValue(): DateRange | null;
+    ngOnDestroy(): void;
+    private openCalendar;
+    private closeCalendar;
+    private getPositionStrategy;
+    private getOverlayOriginElement;
+    private startScrollTracking;
+    private stopScrollTracking;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDateTimePicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDateTimePicker, "vd-date-time-picker", never, { "mode": { "alias": "mode"; "required": false; }; "withTime": { "alias": "withTime"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "showMonthYearSelector": { "alias": "showMonthYearSelector"; "required": false; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "value": { "alias": "value"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "inputFocus": "inputFocus"; "inputBlur": "inputBlur"; }, never, never, true, never>;
+}
+
+declare class VdSingleDateInline implements OnInit {
+    value: Date | null;
+    showMonthYearSelector: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disabled: boolean;
+    valueChange: EventEmitter<Date | null>;
+    currentMonth: Date;
+    today: Date;
+    weekDays: string[];
+    months: string[];
+    years: number[];
+    calendarDays: Array<{
+        date: Date;
+        inMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isDisabled: boolean;
+    }>;
+    ngOnInit(): void;
+    generateYearsArray(): void;
+    prevMonth(event?: Event): void;
+    nextMonth(event?: Event): void;
+    onMonthChange(event: Event): void;
+    onYearChange(event: Event): void;
+    get currentMonthLabel(): string;
+    get selectedMonth(): number;
+    get selectedYear(): number;
+    get selectedMonthValue(): string;
+    get selectedYearValue(): string;
+    generateCalendar(): void;
+    private generateMonthCalendar;
+    createDayObject(date: Date, inMonth: boolean): {
+        date: Date;
+        inMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isDisabled: boolean;
+    };
+    onDateClick(dayObj: any, event: Event): void;
+    isSameDay(d1: Date, d2: Date): boolean;
+    resetCalendarView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdSingleDateInline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdSingleDateInline, "vd-single-date-inline", never, { "value": { "alias": "value"; "required": false; }; "showMonthYearSelector": { "alias": "showMonthYearSelector"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class VdSwitch implements ControlValueAccessor {
+    /** Optional label to display above the switch */
+    label?: string;
+    /** Whether the switch is active/enabled */
+    checked: boolean;
+    /** Whether the switch is disabled */
+    disabled: boolean;
+    /** Emitted when the switch state changes */
+    change: EventEmitter<boolean>;
+    private onChange;
+    private onTouched;
+    /**
+     * Toggle the switch state
+     */
+    toggle(): void;
+    /**
+     * ControlValueAccessor implementation
+     */
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Handle keyboard events (Space to toggle)
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Track blur event for ControlValueAccessor
+     */
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdSwitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdSwitch, "vd-switch", never, { "label": { "alias": "label"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+type VdSidebarRouteMatchMode = 'exact' | 'prefix';
+interface VdSidebarNavItem {
+    label: string;
+    route?: string;
+    matchMode?: VdSidebarRouteMatchMode;
+    icon?: string;
+    children?: VdSidebarNavItem[];
+}
+interface VdSidebarNavSection {
+    title?: string;
+    items: VdSidebarNavItem[];
+    showTitle?: boolean;
+}
+declare class VdSidebar implements OnInit, OnDestroy {
+    private router;
+    sections: VdSidebarNavSection[];
+    expandedItems: Set<string>;
+    currentRoute: string;
+    private destroy$;
+    constructor(router: Router);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    toggleExpand(label: string, event?: Event): void;
+    isExpanded(label: string): boolean;
+    isRouteActive(route: string | undefined, matchMode?: VdSidebarRouteMatchMode): boolean;
+    isItemActive(item: VdSidebarNavItem): boolean;
+    isChildActive(item: VdSidebarNavItem): boolean;
+    private updateExpandedState;
+    private normalizeRoute;
+    private normalizePath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdSidebar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdSidebar, "vd-sidebar", never, { "sections": { "alias": "sections"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type AlertColor = 'primary' | 'success' | 'error' | 'warning' | 'info' | 'neutral';
+declare class VdAlert {
+    /** Alert title (optional) */
+    title?: string;
+    /** Alert description/content (required) */
+    description: string;
+    /** Alert color variant */
+    color: AlertColor;
+    /** Show action button */
+    action: boolean;
+    /** Show close button */
+    closable: boolean;
+    /** Action button text */
+    actionLabel: string;
+    /** Display action button inline */
+    actionInline: boolean;
+    /** Show icon */
+    showIcon: boolean;
+    /** Leading icon name - if not provided, defaults based on color */
+    icon?: string;
+    /** Emitted when close button is clicked */
+    onClose?: () => void;
+    /** Emitted when action button is clicked */
+    onAction?: () => void;
+    /** Get the icon name based on color or custom icon */
+    get iconName(): string;
+    handleClose(): void;
+    handleAction(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdAlert, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdAlert, "vd-alert", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "color": { "alias": "color"; "required": false; }; "action": { "alias": "action"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "actionLabel": { "alias": "actionLabel"; "required": false; }; "actionInline": { "alias": "actionInline"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "onClose": { "alias": "onClose"; "required": false; }; "onAction": { "alias": "onAction"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type VdDrawerSize = 'sm' | 'md' | 'lg';
+type VdDrawerResult = 'primary' | 'secondary' | 'close';
+interface VdDrawerConfig<T = unknown> {
+    title: string;
+    size?: VdDrawerSize;
+    contentTemplate: TemplateRef<T>;
+    context?: T;
+    primaryActionLabel?: string;
+    secondaryActionLabel?: string;
+}
+interface ResolvedConfig$1<T> extends VdDrawerConfig<T> {
+    size: VdDrawerSize;
+}
+declare class VdDrawer<T = unknown> implements OnInit, OnDestroy {
+    private dialogRef;
+    private cdr;
+    readonly config: ResolvedConfig$1<T>;
+    isClosing: boolean;
+    private destroy$;
+    constructor(data: VdDrawerConfig<T>, dialogRef: DialogRef<VdDrawerResult>, cdr: ChangeDetectorRef);
+    get hasActions(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleClose(): void;
+    handlePrimaryAction(): void;
+    handleSecondaryAction(): void;
+    private closeDrawer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDrawer<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDrawer<any>, "vd-drawer", never, {}, {}, never, never, true, never>;
+}
+
+type VdDialogResult = 'primary' | 'secondary' | 'close';
+interface VdDialogConfig<T = unknown> {
+    title: string;
+    contentTemplate: TemplateRef<T>;
+    context?: T;
+    primaryActionLabel?: string;
+    secondaryActionLabel?: string;
+}
+declare class VdDialog<T = unknown> implements OnInit, OnDestroy {
+    private dialogRef;
+    private cdr;
+    readonly config: VdDialogConfig<T>;
+    isClosing: boolean;
+    private destroy$;
+    constructor(data: VdDialogConfig<T>, dialogRef: DialogRef<VdDialogResult>, cdr: ChangeDetectorRef);
+    get hasActions(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleClose(): void;
+    handlePrimaryAction(): void;
+    handleSecondaryAction(): void;
+    private closeDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDialog<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdDialog<any>, "vd-dialog", never, {}, {}, never, never, true, never>;
+}
+
+type VdProgressTrackerState = 'default' | 'active' | 'completed' | 'error' | 'disabled';
+type VdProgressTrackerDirection = 'horizontal' | 'vertical';
+type VdProgressTrackerIndicatorType = 'number' | 'icon';
+type VdProgressTrackerSize = 'sm' | 'lg';
+interface VdProgressTrackerItem {
+    title: string;
+    description?: string;
+    state?: VdProgressTrackerState;
+    indicatorLabel?: string | number;
+    icon?: string;
+}
+declare class VdProgressTracker {
+    items: VdProgressTrackerItem[];
+    direction: VdProgressTrackerDirection;
+    indicatorType: VdProgressTrackerIndicatorType;
+    showDescription: boolean;
+    showConnector: boolean;
+    defaultIcon: string;
+    itemClick: EventEmitter<number>;
+    private readonly completedIcon;
+    private readonly errorIcon;
+    get indicatorSize(): VdProgressTrackerSize;
+    getItemState(item: VdProgressTrackerItem): VdProgressTrackerState;
+    getIndicatorLabel(item: VdProgressTrackerItem, index: number): string;
+    shouldShowLabel(item: VdProgressTrackerItem): boolean;
+    shouldShowIcon(item: VdProgressTrackerItem): boolean;
+    getIndicatorIcon(item: VdProgressTrackerItem): string;
+    onItemClick(item: VdProgressTrackerItem, index: number): void;
+    trackByIndex(index: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdProgressTracker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdProgressTracker, "vd-progress-tracker", never, { "items": { "alias": "items"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "indicatorType": { "alias": "indicatorType"; "required": false; }; "showDescription": { "alias": "showDescription"; "required": false; }; "showConnector": { "alias": "showConnector"; "required": false; }; "defaultIcon": { "alias": "defaultIcon"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+declare class VdRadioButton implements ControlValueAccessor, OnInit {
+    label?: string;
+    description?: string;
+    value: string | number;
+    checked: boolean;
+    disabled: boolean;
+    id?: string;
+    name?: string;
+    ariaLabel?: string;
+    select: EventEmitter<string | number>;
+    inputRef: ElementRef<HTMLInputElement>;
+    inputId: string;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    onInputChange(event: Event): void;
+    onBlur(): void;
+    writeValue(value: string | number): void;
+    registerOnChange(fn: (value: string | number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdRadioButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdRadioButton, "vd-radio-button", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "value": { "alias": "value"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
+type VdRadioGroupDirection = 'vertical' | 'horizontal';
+interface VdRadioGroupItem {
+    label: string;
+    value: string | number;
+    description?: string;
+    disabled?: boolean;
+}
+declare class VdRadioGroup implements ControlValueAccessor, OnChanges {
+    items: VdRadioGroupItem[];
+    direction: VdRadioGroupDirection;
+    value: string | number | null;
+    disabled: boolean;
+    name: string;
+    valueChange: EventEmitter<string | number>;
+    private onChange;
+    private onTouched;
+    ngOnChanges(changes: SimpleChanges): void;
+    onItemSelect(item: VdRadioGroupItem): void;
+    isChecked(item: VdRadioGroupItem): boolean;
+    trackByItem: (_: number, item: VdRadioGroupItem) => string | number;
+    writeValue(value: string | number): void;
+    registerOnChange(fn: (value: string | number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdRadioGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdRadioGroup, "vd-radio-group", never, { "items": { "alias": "items"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class VdVerificationCodeInput implements AfterViewInit {
+    /** Number of code input cells */
+    length: 4 | 6;
+    /** Current value (string of digits) */
+    value: string;
+    /** Whether the input is disabled */
+    disabled: boolean;
+    /** Error state */
+    state: 'error' | null;
+    /** Label text displayed above the input */
+    label?: string;
+    /** Helper text displayed below the input */
+    helperText?: string;
+    /** Whether to auto-focus the first cell on init */
+    autoFocus: boolean;
+    /** Whether to mask the entered digits */
+    mask: boolean;
+    /** Emitted on every value change */
+    valueChange: EventEmitter<string>;
+    /** Emitted when all cells are filled */
+    completed: EventEmitter<string>;
+    hiddenInput: ElementRef<HTMLInputElement>;
+    /** Tracks if input is focused */
+    focused: boolean;
+    /** Caret index for visual focus */
+    caretIndex: number;
+    /** Unique id for input + helper text */
+    inputId: string;
+    helperTextId: string;
+    /** Array representing the number of cells */
+    get cells(): unknown[];
+    ngAfterViewInit(): void;
+    focusInput(): void;
+    onFocus(): void;
+    onBlur(): void;
+    private setCaret;
+    onKeyDown(event: KeyboardEvent): void;
+    onInput(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdVerificationCodeInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdVerificationCodeInput, "vd-verification-code-input", never, { "length": { "alias": "length"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; "label": { "alias": "label"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; }, { "valueChange": "valueChange"; "completed": "completed"; }, never, never, true, never>;
+}
+
+type VdTabType = 'default' | 'boxed';
+type VdTabDirection = 'horizontal' | 'vertical';
+interface VdTabConfig {
+    label: string;
+    value: string;
+    icon?: string;
+    disabled?: boolean;
+}
+declare class VdTab implements OnInit {
+    /** Array of tab configurations */
+    tabs: VdTabConfig[];
+    /** Currently active tab value */
+    value: string;
+    /** Visual type: 'default' (underline) or 'boxed' (filled background) */
+    type: VdTabType;
+    /** Layout direction */
+    direction: VdTabDirection;
+    /** Emitted when active tab changes */
+    valueChange: EventEmitter<string>;
+    /** Emitted when a tab is selected */
+    tabChange: EventEmitter<VdTabConfig>;
+    ngOnInit(): void;
+    selectTab(tab: VdTabConfig): void;
+    isActive(tab: VdTabConfig): boolean;
+    trackByTab(_: number, tab: VdTabConfig): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdTab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdTab, "vd-tab", never, { "tabs": { "alias": "tabs"; "required": false; }; "value": { "alias": "value"; "required": false; }; "type": { "alias": "type"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, { "valueChange": "valueChange"; "tabChange": "tabChange"; }, never, never, true, never>;
+}
+
+type FileInputLayout = 'horizontal' | 'vertical';
+declare class VdFileInput {
+    /** Field label displayed above the dropzone */
+    label?: string;
+    /** Tooltip content for the help icon (shown when label is present) */
+    hintText?: string;
+    /** Whether the field is optional */
+    optional?: boolean;
+    /** Layout variant: compact inline or large centered */
+    layout: FileInputLayout;
+    /** Human-readable supported file types label (e.g. ".png, .jpeg") */
+    supportedFiles?: string;
+    /** Human-readable supported file types label (e.g. ".png, .jpeg") */
+    supportingText?: string;
+    /** Maximum file size label displayed to the user (e.g. "12 MB") */
+    maxSize?: string;
+    /** Whether multiple files can be selected */
+    multiple: boolean;
+    /** Whether the input is disabled */
+    disabled: boolean;
+    /** Validation state */
+    state: 'error' | null;
+    /** Helper text shown below the dropzone (e.g. validation message) */
+    helperText?: string;
+    /** Emitted when the selected files list changes (add or remove) */
+    filesChange: EventEmitter<File[]>;
+    fileInputRef: ElementRef<HTMLInputElement>;
+    /** Internal list of selected files */
+    selectedFiles: File[];
+    /** Internal drag-over flag */
+    isDragOver: boolean;
+    /** Computed unique id */
+    inputId: string;
+    /** Whether the dropzone should be hidden (single mode with a file selected) */
+    get hideDropzone(): boolean;
+    /** Open the native file picker */
+    openFilePicker(): void;
+    /** Handle file selection via native input */
+    onFileSelected(event: Event): void;
+    /** Remove a specific file from the list */
+    removeFile(index: number, event: MouseEvent): void;
+    /** Format bytes to human-readable size */
+    formatSize(bytes: number): string;
+    /** Handle dragover */
+    onDragOver(event: DragEvent): void;
+    /** Handle dragleave */
+    onDragLeave(event: DragEvent): void;
+    /** Handle drop */
+    onDrop(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdFileInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdFileInput, "vd-file-input", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "supportedFiles": { "alias": "supportedFiles"; "required": false; }; "supportingText": { "alias": "supportingText"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; }, { "filesChange": "filesChange"; }, never, never, true, never>;
+}
+
+declare class VdNumberInput {
+    label?: string;
+    hintText?: string;
+    helperText?: string;
+    optional?: boolean;
+    leadingIcon?: string;
+    trailingActionIcon?: string;
+    placeholder: string;
+    value: number | null;
+    min?: number;
+    max?: number;
+    step?: number | 'any';
+    readOnly?: boolean;
+    disabled?: boolean;
+    state: 'success' | 'error' | 'warning' | null;
+    valueChange: EventEmitter<number | null>;
+    valueCommit: EventEmitter<number | null>;
+    trailingActionClick: EventEmitter<void>;
+    inputFocus: EventEmitter<void>;
+    inputId: string;
+    showHint: boolean;
+    isFocused: boolean;
+    onFocus(): void;
+    inputElement: ElementRef<HTMLInputElement>;
+    focusInput(): void;
+    onBlur(): void;
+    onInput(event: Event): void;
+    onTrailingActionClick(): void;
+    toggleHint(): void;
+    get visualState(): 'success' | 'error' | 'warning' | null;
+    get trailingStateIcon(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdNumberInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdNumberInput, "vd-number-input", never, { "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingActionIcon": { "alias": "trailingActionIcon"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "valueChange": "valueChange"; "valueCommit": "valueCommit"; "trailingActionClick": "trailingActionClick"; "inputFocus": "inputFocus"; }, never, never, true, never>;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    url?: string;
+    [key: string]: any;
+}
+declare class VdBreadcrumb {
+    items: BreadcrumbItem[];
+    separatorIcon: string;
+    size: 'sm' | 'md' | 'lg';
+    itemClick: EventEmitter<BreadcrumbItem>;
+    get maxItems(): number;
+    get showOverflow(): boolean;
+    get visibleItems(): BreadcrumbItem[];
+    get overflowItems(): BreadcrumbItem[];
+    private router;
+    onItemClick(event: Event, item: BreadcrumbItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdBreadcrumb, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdBreadcrumb, "vd-breadcrumb", never, { "items": { "alias": "items"; "required": false; }; "separatorIcon": { "alias": "separatorIcon"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+declare class VdNavbar {
+    logoUrl?: string;
+    logoAlt?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdNavbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdNavbar, "vd-navbar", never, { "logoUrl": { "alias": "logoUrl"; "required": false; }; "logoAlt": { "alias": "logoAlt"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class VdEmptyState {
+    /** Heading shown as the primary message. */
+    title: string;
+    /** Supporting description shown below the title (optional). */
+    description?: string;
+    /** Icon name rendered at the top of the empty state. */
+    icon: string;
+    /** Show or hide the icon container. */
+    showIcon: boolean;
+    /** Boxed container style with padding, border and background. */
+    boxed: boolean;
+    /** Primary action button text. Button is visible only when label is provided. */
+    primaryActionLabel: string;
+    /** Secondary action button text. Button is visible only when label is provided. */
+    secondaryActionLabel: string;
+    /** Emitted when the primary action button is clicked. */
+    primaryActionClick: EventEmitter<void>;
+    /** Emitted when the secondary action button is clicked. */
+    secondaryActionClick: EventEmitter<void>;
+    get hasPrimaryAction(): boolean;
+    get hasSecondaryAction(): boolean;
+    onPrimaryActionClick(): void;
+    onSecondaryActionClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdEmptyState, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdEmptyState, "vd-empty-state", never, { "title": { "alias": "title"; "required": true; }; "description": { "alias": "description"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "boxed": { "alias": "boxed"; "required": false; }; "primaryActionLabel": { "alias": "primaryActionLabel"; "required": false; }; "secondaryActionLabel": { "alias": "secondaryActionLabel"; "required": false; }; }, { "primaryActionClick": "primaryActionClick"; "secondaryActionClick": "secondaryActionClick"; }, never, never, true, never>;
+}
+
+declare class VdLoadingState {
+    /** Heading shown as the primary message. */
+    title: string;
+    /** Supporting description shown below the title (optional). */
+    description?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdLoadingState, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdLoadingState, "vd-loading-state", never, { "title": { "alias": "title"; "required": true; }; "description": { "alias": "description"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VdAngularComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdAngularComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VdAngularComponentsModule, never, [typeof VdButton, typeof VdIcon, typeof VdIconButton, typeof VdToast, typeof VdInput, typeof VdCheckbox, typeof VdCheckboxGroup, typeof VdTooltip, typeof VdBadge, typeof VdDivider, typeof VdPagination, typeof VdDropdown, typeof VdDropdownItem, typeof VdDropdownItemLink, typeof VdDropdownItemGroup, typeof VdDropdownItemDivider, typeof VdDatatable, typeof VdAccordion, typeof VdTextarea, typeof VdSelect, typeof VdSingleDatePicker, typeof VdRangeDatePicker, typeof VdTimePicker, typeof VdDateTimePicker, typeof VdSingleDateInline, typeof VdRangeDateInline, typeof VdSwitch, typeof VdSidebar, typeof VdAlert, typeof VdDrawer, typeof VdDialog, typeof VdProgressTracker, typeof VdRadioButton, typeof VdRadioGroup, typeof VdVerificationCodeInput, typeof VdTab, typeof VdFileInput, typeof VdNumberInput, typeof VdBreadcrumb, typeof VdNavbar, typeof VdEmptyState, typeof VdLoadingState], [typeof VdButton, typeof VdIcon, typeof VdIconButton, typeof VdToast, typeof VdInput, typeof VdCheckbox, typeof VdCheckboxGroup, typeof VdTooltip, typeof VdBadge, typeof VdDivider, typeof VdPagination, typeof VdDropdown, typeof VdDropdownItem, typeof VdDropdownItemLink, typeof VdDropdownItemGroup, typeof VdDropdownItemDivider, typeof VdDatatable, typeof VdAccordion, typeof VdTextarea, typeof VdSelect, typeof VdRangeDatePicker, typeof VdSingleDatePicker, typeof VdTimePicker, typeof VdDateTimePicker, typeof VdSingleDateInline, typeof VdSwitch, typeof VdRangeDateInline, typeof VdSidebar, typeof VdAlert, typeof VdDrawer, typeof VdDialog, typeof VdProgressTracker, typeof VdRadioButton, typeof VdRadioGroup, typeof VdVerificationCodeInput, typeof VdTab, typeof VdFileInput, typeof VdNumberInput, typeof VdBreadcrumb, typeof VdNavbar, typeof VdEmptyState, typeof VdLoadingState]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VdAngularComponentsModule>;
+}
+
+declare class ToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ToastModule, never, [typeof i1.CommonModule, typeof VdToast], [typeof VdToast]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ToastModule>;
+}
+
+declare class VdTooltipDirective implements OnDestroy {
+    text: string;
+    vdTooltipPosition: TooltipPosition;
+    private overlayRef?;
+    private overlay;
+    private elementRef;
+    private viewContainerRef;
+    ngOnDestroy(): void;
+    show(): void;
+    hide(): void;
+    private destroy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VdTooltipDirective, "[vdTooltip]", never, { "text": { "alias": "vdTooltip"; "required": false; }; "vdTooltipPosition": { "alias": "vdTooltipPosition"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type DialogColor = 'default' | 'error';
+interface VdConfirmationDialogConfig {
+    title: string;
+    description?: string;
+    icon?: string;
+    color?: DialogColor;
+    cancelLabel?: string;
+    confirmLabel?: string;
+}
+interface ResolvedConfig {
+    title: string;
+    description?: string;
+    icon?: string;
+    color: DialogColor;
+    cancelLabel: string;
+    confirmLabel: string;
+}
+declare class VdConfirmationDialog implements OnInit, OnDestroy {
+    private dialogRef;
+    private cdr;
+    readonly config: ResolvedConfig;
+    isClosing: boolean;
+    private destroy$;
+    constructor(data: VdConfirmationDialogConfig, dialogRef: DialogRef<'confirm' | 'cancel'>, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleCancel(): void;
+    handleConfirm(): void;
+    private closeDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdConfirmationDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdConfirmationDialog, "vd-confirmation-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class VdConfirmationDialogService {
+    private dialog;
+    private overlay;
+    private scrollStrategyOptions;
+    private document;
+    private scrollStrategy;
+    constructor(dialog: Dialog, overlay: Overlay, scrollStrategyOptions: ScrollStrategyOptions, document: Document);
+    confirm(config: VdConfirmationDialogConfig): Promise<'confirm' | 'cancel'>;
+    private blurActiveElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdConfirmationDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VdConfirmationDialogService>;
+}
+
+declare class VdDrawerService {
+    private dialog;
+    private overlay;
+    private scrollStrategyOptions;
+    private document;
+    private scrollStrategy;
+    private activeDrawerCount;
+    private removeScrollLockListeners;
+    constructor(dialog: Dialog, overlay: Overlay, scrollStrategyOptions: ScrollStrategyOptions, document: Document);
+    open<T = unknown>(config: VdDrawerConfig<T>): Promise<VdDrawerResult>;
+    private lockBackgroundScroll;
+    private unlockBackgroundScroll;
+    private blurActiveElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDrawerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VdDrawerService>;
+}
+
+declare class VdDialogService {
+    private dialog;
+    private overlay;
+    private scrollStrategyOptions;
+    private document;
+    private scrollStrategy;
+    constructor(dialog: Dialog, overlay: Overlay, scrollStrategyOptions: ScrollStrategyOptions, document: Document);
+    open<T = unknown>(config: VdDialogConfig<T>): Promise<VdDialogResult>;
+    private blurActiveElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VdDialogService>;
+}
+
+export { ToastModule, VdAccordion, VdAlert, VdAngularComponentsModule, VdBadge, VdBreadcrumb, VdButton, VdCheckbox, VdCheckboxGroup, VdConfirmationDialog, VdConfirmationDialogService, VdDatatable, VdDateTimePicker, VdDialog, VdDialogService, VdDivider, VdDrawer, VdDrawerService, VdDropdown, VdDropdownItem, VdDropdownItemDivider, VdDropdownItemGroup, VdDropdownItemLink, VdEmptyState, VdFileInput, VdIcon, VdIconButton, VdInput, VdLoadingState, VdNavbar, VdNumberInput, VdPagination, VdProgressTracker, VdRadioButton, VdRadioGroup, VdRangeDateInline, VdRangeDatePicker, VdSelect, VdSidebar, VdSingleDateInline, VdSingleDatePicker, VdSwitch, VdTab, VdTextarea, VdTimePicker, VdToast, VdToastService, VdTooltip, VdTooltipDirective, VdVerificationCodeInput };
+export type { BreadcrumbItem, DatatableCellContext, DateRange, DialogColor, Toast, ToastColor, ToastConfig, ToastPosition, TooltipPosition, VdCheckboxGroupDirection, VdCheckboxGroupItem, VdConfirmationDialogConfig, VdDatatableAction, VdDatatableColumn, VdDialogConfig, VdDialogResult, VdDrawerConfig, VdDrawerResult, VdDrawerSize, VdProgressTrackerDirection, VdProgressTrackerIndicatorType, VdProgressTrackerItem, VdProgressTrackerSize, VdProgressTrackerState, VdRadioGroupDirection, VdRadioGroupItem, VdSelectOption, VdSidebarNavItem, VdSidebarNavSection, VdSidebarRouteMatchMode, VdTabConfig, VdTabDirection, VdTabType };