@sabrenski/spire-ui 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,4981 @@
+import { AllowedComponentProps } from 'vue';
+import { BubbleDataPoint } from 'chart.js';
+import { Chart } from 'chart.js';
+import { ChartData } from 'chart.js';
+import { ChartOptions } from 'chart.js';
+import { ChartType } from 'chart.js';
+import { ChartTypeRegistry } from 'chart.js';
+import { Component } from 'vue';
+import { ComponentCustomProperties } from 'vue';
+import { ComponentCustomProps } from 'vue';
+import { ComponentInternalInstance } from 'vue';
+import { ComponentOptionsBase } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComponentPublicInstance } from 'vue';
+import { ComputedRef } from 'vue';
+import { DebuggerEvent } from 'vue';
+import { DefineComponent } from 'vue';
+import { GlobalComponents } from 'vue';
+import { GlobalDirectives } from 'vue';
+import { InjectionKey } from 'vue';
+import { InputHTMLAttributes } from 'vue';
+import { nextTick } from 'vue';
+import { OnCleanup } from '@vue/reactivity';
+import { Point } from 'chart.js';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { ShallowRef } from 'vue';
+import { ShallowUnwrapRef } from 'vue';
+import { Slot } from 'vue';
+import { VNode } from 'vue';
+import { VNodeProps } from 'vue';
+import { WatchOptions } from 'vue';
+import { WatchStopHandle } from 'vue';
+
+declare const __VLS_component: DefineComponent<AccordionRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: string | string[] | undefined) => any;
+}, string, PublicProps, Readonly<AccordionRootProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;
+}>, {
+collapsible: boolean;
+multiple: boolean;
+variant: AccordionVariant;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_10: DefineComponent<BreadcrumbLinkProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BreadcrumbLinkProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_11: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLSpanElement>;
+
+declare const __VLS_component_12: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLLIElement>;
+
+declare const __VLS_component_13: DefineComponent<BreadcrumbEllipsisProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BreadcrumbEllipsisProps> & Readonly<{}>, {
+items: BreadcrumbEllipsisItem[];
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLIElement>;
+
+declare const __VLS_component_14: DefineComponent<ButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+click: (event: MouseEvent) => any;
+}, string, PublicProps, Readonly<ButtonProps> & Readonly<{
+onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+variant: "primary" | "secondary" | "destructive" | "ghost" | "outline";
+type: "button" | "submit" | "reset";
+size: "xs" | "sm" | "md" | "lg" | "xl";
+disabled: boolean;
+as: string | Component;
+loading: boolean;
+block: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_15: DefineComponent<CalloutProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+close: () => any;
+}, string, PublicProps, Readonly<CalloutProps> & Readonly<{
+onClose?: (() => any) | undefined;
+}>, {
+variant: CalloutVariant;
+accent: boolean;
+dismissible: boolean;
+hideIcon: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_16: DefineComponent<CardProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+click: (event: MouseEvent) => any;
+}, string, PublicProps, Readonly<CardProps> & Readonly<{
+onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+variant: CardVariant;
+disabled: boolean;
+as: string | Component;
+loading: boolean;
+interactive: boolean;
+horizontal: boolean;
+padding: CardPadding;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_17: DefineComponent<CardHeaderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardHeaderProps> & Readonly<{}>, {
+align: "start" | "center";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_18: DefineComponent<CardContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardContentProps> & Readonly<{}>, {
+flush: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_19: DefineComponent<CardFooterProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardFooterProps> & Readonly<{}>, {
+align: "start" | "center" | "end" | "between";
+borderless: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_2: DefineComponent<AccordionItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionItemProps> & Readonly<{}>, {
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_20: DefineComponent<BaseChartProps, {
+chart: ShallowRef<Chart<keyof ChartTypeRegistry, (number | Point | [number, number] | BubbleDataPoint | null)[], unknown> | null, Chart<keyof ChartTypeRegistry, (number | Point | [number, number] | BubbleDataPoint | null)[], unknown> | null>;
+toggleDataset: typeof toggleDataset;
+legendItems: Ref<    {
+label: string;
+color: string;
+hidden: boolean;
+datasetIndex: number;
+}[], LegendItem[] | {
+label: string;
+color: string;
+hidden: boolean;
+datasetIndex: number;
+}[]>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+legendClick: (item: LegendItem, index: number) => any;
+pointClick: (data: PointClickData) => any;
+}, string, PublicProps, Readonly<BaseChartProps> & Readonly<{
+onLegendClick?: ((item: LegendItem, index: number) => any) | undefined;
+onPointClick?: ((data: PointClickData) => any) | undefined;
+}>, {
+height: string | number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+containerRef: HTMLDivElement;
+canvasRef: HTMLCanvasElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_21: DefineComponent<LineChartProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+pointClick: (data: PointClickData) => any;
+}, string, PublicProps, Readonly<LineChartProps> & Readonly<{
+onPointClick?: ((data: PointClickData) => any) | undefined;
+}>, {
+fill: boolean;
+height: string | number;
+pointRadius: number;
+tension: number;
+showPoints: boolean;
+showGrid: boolean;
+showXAxis: boolean;
+showYAxis: boolean;
+showLegend: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_22: DefineComponent<BarChartProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+pointClick: (data: PointClickData) => any;
+}, string, PublicProps, Readonly<BarChartProps> & Readonly<{
+onPointClick?: ((data: PointClickData) => any) | undefined;
+}>, {
+height: string | number;
+horizontal: boolean;
+borderRadius: number;
+stacked: boolean;
+showGrid: boolean;
+showXAxis: boolean;
+showYAxis: boolean;
+showLegend: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_23: DefineComponent<DonutChartProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+segmentClick: (data: SegmentClickData) => any;
+}, string, PublicProps, Readonly<DonutChartProps> & Readonly<{
+onSegmentClick?: ((data: SegmentClickData) => any) | undefined;
+}>, {
+height: string | number;
+cutout: number;
+showLegend: boolean;
+legendPosition: "top" | "bottom" | "left" | "right";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_24: DefineComponent<DataTableProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:selectedIds": (value: (string | number)[]) => any;
+"sort-change": (value: SortState) => any;
+"row-click": (row: Record<string, unknown>, index: number) => any;
+"update:page": (value: number) => any;
+"update:pageSize": (value: number) => any;
+"pagination-change": (value: {
+page: number;
+pageSize: number;
+}) => any;
+"update:search": (value: string) => any;
+"update:filters": (value: Record<string, string>) => any;
+"filter-change": (value: {
+search: string;
+filters: Record<string, string>;
+}) => any;
+"update:expandedIds": (value: (string | number)[]) => any;
+"row-expand": (row: Record<string, unknown>, expanded: boolean) => any;
+"column-resize": (columnKey: string, width: number) => any;
+}, string, PublicProps, Readonly<DataTableProps> & Readonly<{
+"onUpdate:selectedIds"?: ((value: (string | number)[]) => any) | undefined;
+"onSort-change"?: ((value: SortState) => any) | undefined;
+"onRow-click"?: ((row: Record<string, unknown>, index: number) => any) | undefined;
+"onUpdate:page"?: ((value: number) => any) | undefined;
+"onUpdate:pageSize"?: ((value: number) => any) | undefined;
+"onPagination-change"?: ((value: {
+page: number;
+pageSize: number;
+}) => any) | undefined;
+"onUpdate:search"?: ((value: string) => any) | undefined;
+"onUpdate:filters"?: ((value: Record<string, string>) => any) | undefined;
+"onFilter-change"?: ((value: {
+search: string;
+filters: Record<string, string>;
+}) => any) | undefined;
+"onUpdate:expandedIds"?: ((value: (string | number)[]) => any) | undefined;
+"onRow-expand"?: ((row: Record<string, unknown>, expanded: boolean) => any) | undefined;
+"onColumn-resize"?: ((columnKey: string, width: number) => any) | undefined;
+}>, {
+search: string;
+size: "sm" | "md" | "lg";
+bordered: boolean;
+page: number;
+loading: boolean;
+pageSize: number;
+selectable: boolean;
+selectedIds: (string | number)[];
+rowKey: string;
+skeletonRows: number;
+striped: boolean;
+hoverable: boolean;
+emptyMessage: string;
+stickyHeader: boolean;
+pagination: boolean | PaginationConfig;
+serverSide: boolean;
+searchable: boolean;
+searchPlaceholder: string;
+filterable: boolean;
+filters: Record<string, string>;
+resizable: boolean;
+expandable: boolean;
+expandedIds: (string | number)[];
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+tableRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_25: DefineComponent<DatePickerProps, {
+open: typeof openCalendar;
+close: typeof closeCalendar;
+toggle: () => void;
+applyPreset: typeof applyPreset;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | [string, string]) => any;
+}, string, PublicProps, Readonly<DatePickerProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | [string, string]) => any) | undefined;
+}>, {
+size: "xs" | "sm" | "md" | "lg" | "xl";
+disabled: boolean;
+required: boolean;
+mode: "single" | "range";
+placeholder: string;
+block: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+popoverRef: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly placement?: PopoverPlacement | undefined;
+readonly offset?: number | undefined;
+readonly arrow?: boolean | undefined;
+readonly disabled?: boolean | undefined;
+readonly width?: "auto" | number | undefined;
+readonly closeOnEscape?: boolean | undefined;
+readonly closeOnClickOutside?: boolean | undefined;
+readonly lockScroll?: boolean | undefined;
+readonly trapFocus?: boolean | undefined;
+readonly onClose?: (() => any) | undefined;
+readonly onOpen?: (() => any) | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+} & {
+triggerRef: HTMLDivElement;
+popoverRef: HTMLDivElement;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: ((event: "close") => void) & ((event: "open") => void);
+$el: HTMLDivElement;
+$options: ComponentOptionsBase<Readonly<PopoverProps> & Readonly<{
+onClose?: (() => any) | undefined;
+onOpen?: (() => any) | undefined;
+}>, {
+open: () => void;
+close: () => void;
+toggle: () => void;
+isOpen: Ref<boolean, boolean>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+close: () => any;
+open: () => any;
+}, string, {
+disabled: boolean;
+width: "auto" | number;
+placement: PopoverPlacement;
+offset: number;
+arrow: boolean;
+closeOnEscape: boolean;
+closeOnClickOutside: boolean;
+lockScroll: boolean;
+trapFocus: boolean;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{
+disabled: boolean;
+width: "auto" | number;
+placement: PopoverPlacement;
+offset: number;
+arrow: boolean;
+closeOnEscape: boolean;
+closeOnClickOutside: boolean;
+lockScroll: boolean;
+trapFocus: boolean;
+}> & Omit<Readonly<PopoverProps> & Readonly<{
+onClose?: (() => any) | undefined;
+onOpen?: (() => any) | undefined;
+}>, "close" | "toggle" | "isOpen" | "open" | ("disabled" | "width" | "placement" | "offset" | "arrow" | "closeOnEscape" | "closeOnClickOutside" | "lockScroll" | "trapFocus")> & ShallowUnwrapRef<    {
+open: () => void;
+close: () => void;
+toggle: () => void;
+isOpen: Ref<boolean, boolean>;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+trigger?(_: {
+open: boolean;
+toggle: () => void;
+close: () => void;
+}): any;
+default?(_: {
+close: () => void;
+}): any;
+};
+}) | null;
+triggerRef: HTMLDivElement;
+inputRef: HTMLInputElement;
+calendarRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_26: DefineComponent<DrawerProps, {
+close: typeof close_2;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: boolean) => any;
+close: () => any;
+open: () => any;
+}, string, PublicProps, Readonly<DrawerProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+onClose?: (() => any) | undefined;
+onOpen?: (() => any) | undefined;
+}>, {
+modelValue: boolean;
+variant: DrawerVariant;
+size: DrawerSize;
+placement: DrawerPlacement;
+closeOnEscape: boolean;
+maskClosable: boolean;
+showClose: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+drawerRef: HTMLDivElement;
+}, any>;
+
+declare const __VLS_component_27: DefineComponent<DropdownItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+click: (event: MouseEvent | KeyboardEvent) => any;
+}, string, PublicProps, Readonly<DropdownItemProps> & Readonly<{
+onClick?: ((event: MouseEvent | KeyboardEvent) => any) | undefined;
+}>, {
+disabled: boolean;
+danger: boolean;
+preventClose: boolean;
+chevron: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+itemRef: unknown;
+}, any>;
+
+declare const __VLS_component_28: DefineComponent<DropdownSubTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DropdownSubTriggerProps> & Readonly<{}>, {
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+triggerRef: HTMLButtonElement;
+}, HTMLButtonElement>;
+
+declare const __VLS_component_29: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+menuRef: HTMLDivElement;
+}, any>;
+
+declare const __VLS_component_3: DefineComponent<AccordionTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionTriggerProps> & Readonly<{}>, {
+hideIndicator: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLHeadingElement>;
+
+declare const __VLS_component_30: DefineComponent<EmptyStateProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<EmptyStateProps> & Readonly<{}>, {
+variant: EmptyStateVariant;
+compact: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_31: DefineComponent<ChoiceChipGroupProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number | (string | number)[] | undefined) => any;
+change: (value: string | number | (string | number)[] | undefined) => any;
+}, string, PublicProps, Readonly<ChoiceChipGroupProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+onChange?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+}>, {
+type: "single" | "multiple";
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_32: DefineComponent<HeadingProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<HeadingProps> & Readonly<{}>, {
+size: HeadingSize;
+as: HeadingTag;
+align: "left" | "center" | "right";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_33: DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number) => any;
+blur: (event: FocusEvent) => any;
+focus: (event: FocusEvent) => any;
+}, string, PublicProps, Readonly<InputProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+onBlur?: ((event: FocusEvent) => any) | undefined;
+onFocus?: ((event: FocusEvent) => any) | undefined;
+}>, {
+type: "text" | "email" | "password" | "search" | "tel" | "url" | "number";
+size: "xs" | "sm" | "md" | "lg" | "xl";
+disabled: boolean;
+required: boolean;
+loading: boolean;
+block: boolean;
+readonly: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_34: DefineComponent<ModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: boolean) => any;
+close: () => any;
+}, string, PublicProps, Readonly<ModalProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+onClose?: (() => any) | undefined;
+}>, {
+modelValue: boolean;
+size: ModalSize;
+persistent: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+dialogRef: HTMLDialogElement;
+}, HTMLDialogElement>;
+
+declare const __VLS_component_35: DefineComponent<PopoverProps, {
+open: typeof open_2;
+close: typeof close_3;
+toggle: typeof toggle;
+isOpen: Ref<boolean, boolean>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+close: () => any;
+open: () => any;
+}, string, PublicProps, Readonly<PopoverProps> & Readonly<{
+onClose?: (() => any) | undefined;
+onOpen?: (() => any) | undefined;
+}>, {
+disabled: boolean;
+width: "auto" | number;
+placement: PopoverPlacement;
+offset: number;
+arrow: boolean;
+closeOnEscape: boolean;
+closeOnClickOutside: boolean;
+lockScroll: boolean;
+trapFocus: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+triggerRef: HTMLDivElement;
+popoverRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_36: DefineComponent<SidebarLayoutProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SidebarLayoutProps> & Readonly<{}>, {
+sidebarPosition: "left" | "right";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_37: DefineComponent<SidebarRootProps, {
+toggle: typeof toggle_2;
+collapsed: ComputedRef<boolean>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: boolean) => any;
+}, string, PublicProps, Readonly<SidebarRootProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+modelValue: boolean;
+expandedWidth: string;
+collapsedWidth: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
+
+declare const __VLS_component_38: DefineComponent<SidebarItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SidebarItemProps> & Readonly<{}>, {
+disabled: boolean;
+as: string | Component;
+active: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_39: DefineComponent<SidebarGroupProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SidebarGroupProps> & Readonly<{}>, {
+showSeparator: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_4: DefineComponent<AccordionContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionContentProps> & Readonly<{}>, {
+lazy: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_40: DefineComponent<StepperRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: number) => any;
+}, string, PublicProps, Readonly<StepperRootProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+modelValue: number;
+linear: boolean;
+orientation: StepperOrientation;
+errorSteps: number[];
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_41: DefineComponent<StepperItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<StepperItemProps> & Readonly<{}>, {
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_42: DefineComponent<StepperTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<StepperTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
+
+declare const __VLS_component_43: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+declare const __VLS_component_44: DefineComponent<TabsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number) => any;
+}, string, PublicProps, Readonly<TabsProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {
+variant: "line" | "pill";
+block: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+tabListRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_45: DefineComponent<TextareaProps, {
+focus: () => void | undefined;
+blur: () => void | undefined;
+select: () => void | undefined;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string) => any;
+blur: (event: FocusEvent) => any;
+focus: (event: FocusEvent) => any;
+}, string, PublicProps, Readonly<TextareaProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string) => any) | undefined;
+onBlur?: ((event: FocusEvent) => any) | undefined;
+onFocus?: ((event: FocusEvent) => any) | undefined;
+}>, {
+disabled: boolean;
+required: boolean;
+block: boolean;
+readonly: boolean;
+rows: number;
+autosize: boolean;
+showCount: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+textareaRef: HTMLTextAreaElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_46: DefineComponent<TextProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TextProps> & Readonly<{}>, {
+size: TextSize;
+as: TextTag;
+align: "left" | "center" | "right" | "justify";
+weight: TextWeight;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_47: DefineComponent<TimelineProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TimelineProps> & Readonly<{}>, {
+align: TimelineAlign;
+lineStyle: TimelineLineStyle;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_48: DefineComponent<TimelineItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TimelineItemProps> & Readonly<{}>, {
+dotColor: TimelineDotColor;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_49: DefineComponent<ToggleButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: boolean) => any;
+change: (value: boolean) => any;
+}, string, PublicProps, Readonly<ToggleButtonProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+onChange?: ((value: boolean) => any) | undefined;
+}>, {
+size: "sm" | "md" | "lg";
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
+
+declare const __VLS_component_5: DefineComponent<BadgeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BadgeProps> & Readonly<{}>, {
+variant: BadgeVariant;
+max: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLSpanElement>;
+
+declare const __VLS_component_50: DefineComponent<ToggleGroupProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number | (string | number)[] | undefined) => any;
+change: (value: string | number | (string | number)[] | undefined) => any;
+}, string, PublicProps, Readonly<ToggleGroupProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+onChange?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+}>, {
+type: "single" | "multiple";
+size: "sm" | "md" | "lg";
+disabled: boolean;
+orientation: "horizontal" | "vertical";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_51: DefineComponent<TooltipProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TooltipProps> & Readonly<{}>, {
+disabled: boolean;
+delay: number;
+placement: Placement;
+offset: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+triggerRef: HTMLSpanElement;
+contentRef: HTMLDivElement;
+}, any>;
+
+declare const __VLS_component_52: DefineComponent<TreeViewProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: string | string[] | undefined) => any;
+"update:expandedIds": (value: string[]) => any;
+}, string, PublicProps, Readonly<TreeViewProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;
+"onUpdate:expandedIds"?: ((value: string[]) => any) | undefined;
+}>, {
+expandedIds: string[];
+multiSelect: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_53: DefineComponent<TreeViewItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TreeViewItemProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_54: DefineComponent<ContainerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ContainerProps> & Readonly<{}>, {
+as: string;
+fluid: boolean;
+centered: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_55: DefineComponent<StackProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<StackProps> & Readonly<{}>, {
+as: string;
+align: "start" | "center" | "end" | "stretch" | "baseline";
+justify: "start" | "center" | "end" | "between" | "around" | "evenly";
+inline: boolean;
+wrap: boolean;
+direction: "row" | "column" | "row-reverse" | "column-reverse";
+gap: SpacingToken;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_56: DefineComponent<GridProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<GridProps> & Readonly<{}>, {
+as: string;
+columns: ColumnCount | ResponsiveColumns;
+gap: SpacingToken;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_57: DefineComponent<GridItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<GridItemProps> & Readonly<{}>, {
+span: SpanCount | ResponsiveSpan;
+as: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_6: DefineComponent<BadgeContainerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BadgeContainerProps> & Readonly<{}>, {
+position: BadgePosition;
+offsetX: string;
+offsetY: string;
+cutout: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLSpanElement>;
+
+declare const __VLS_component_7: DefineComponent<BreadcrumbRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BreadcrumbRootProps> & Readonly<{}>, {
+separator: Component | string | (() => VNode);
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
+
+declare const __VLS_component_8: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLOListElement>;
+
+declare const __VLS_component_9: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLLIElement>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_10(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_11(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+
+declare function __VLS_template_12(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): unknown;
+    }> & {
+        default(): unknown;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+
+declare function __VLS_template_13(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+
+declare function __VLS_template_14(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_15(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?(): unknown;
+        title?(): unknown;
+        icon?(): unknown;
+        action?(): unknown;
+    }> & {
+        default?(): unknown;
+        title?(): unknown;
+        icon?(): unknown;
+        action?(): unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_16(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_17(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        subtitle?(_: {}): any;
+        default?(_: {}): any;
+        actions?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_18(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_19(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_20(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+        fallback?: () => unknown;
+    }> & {
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+        fallback?: () => unknown;
+    };
+    refs: {
+        containerRef: HTMLDivElement;
+        canvasRef: HTMLCanvasElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_21(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+    }> & {
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_22(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+    }> & {
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_23(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+        center?: () => unknown;
+    }> & {
+        legend?: (props: {
+            items: LegendItem[];
+            toggle: (index: number) => void;
+        }) => unknown;
+        tooltip?: (props: {
+            data: TooltipData | null;
+        }) => unknown;
+        center?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_24(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`header-${string}`, (_: {
+        column: DataTableColumn;
+    }) => any>> & Partial<Record<`cell-${string}`, (_: {
+        value: unknown;
+        row: Record<string, unknown>;
+        column: DataTableColumn;
+        index: number;
+    }) => any>> & {
+        toolbar?(_: {}): any;
+        empty?(_: {}): any;
+        expanded?(_: {
+            row: Record<string, unknown>;
+            index: number;
+        }): any;
+    };
+    refs: {
+        tableRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_25(): {
+    attrs: Partial<{}>;
+    slots: {
+        sidebar?(_: {
+            applyPreset: typeof applyPreset;
+        }): any;
+        sidebar?(_: {
+            applyPreset: typeof applyPreset;
+        }): any;
+    };
+    refs: {
+        popoverRef: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly placement?: PopoverPlacement | undefined;
+                readonly offset?: number | undefined;
+                readonly arrow?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly width?: "auto" | number | undefined;
+                readonly closeOnEscape?: boolean | undefined;
+                readonly closeOnClickOutside?: boolean | undefined;
+                readonly lockScroll?: boolean | undefined;
+                readonly trapFocus?: boolean | undefined;
+                readonly onClose?: (() => any) | undefined;
+                readonly onOpen?: (() => any) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                triggerRef: HTMLDivElement;
+                popoverRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "close") => void) & ((event: "open") => void);
+            $el: HTMLDivElement;
+            $options: ComponentOptionsBase<Readonly<PopoverProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+            onOpen?: (() => any) | undefined;
+            }>, {
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+            isOpen: Ref<boolean, boolean>;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            close: () => any;
+            open: () => any;
+            }, string, {
+            disabled: boolean;
+            width: "auto" | number;
+            placement: PopoverPlacement;
+            offset: number;
+            arrow: boolean;
+            closeOnEscape: boolean;
+            closeOnClickOutside: boolean;
+            lockScroll: boolean;
+            trapFocus: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            disabled: boolean;
+            width: "auto" | number;
+            placement: PopoverPlacement;
+            offset: number;
+            arrow: boolean;
+            closeOnEscape: boolean;
+            closeOnClickOutside: boolean;
+            lockScroll: boolean;
+            trapFocus: boolean;
+        }> & Omit<Readonly<PopoverProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+            onOpen?: (() => any) | undefined;
+        }>, "close" | "toggle" | "isOpen" | "open" | ("disabled" | "width" | "placement" | "offset" | "arrow" | "closeOnEscape" | "closeOnClickOutside" | "lockScroll" | "trapFocus")> & ShallowUnwrapRef<    {
+        open: () => void;
+        close: () => void;
+        toggle: () => void;
+        isOpen: Ref<boolean, boolean>;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                trigger?(_: {
+                    open: boolean;
+                    toggle: () => void;
+                    close: () => void;
+                }): any;
+                default?(_: {
+                    close: () => void;
+                }): any;
+            };
+        }) | null;
+        triggerRef: HTMLDivElement;
+        inputRef: HTMLInputElement;
+        calendarRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_26(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {
+            close: typeof close_2;
+        }): any;
+    };
+    refs: {
+        drawerRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_27(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        itemRef: unknown;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_28(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLButtonElement;
+    };
+    rootEl: HTMLButtonElement;
+};
+
+declare function __VLS_template_29(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        menuRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_3(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        icon?(_: {
+            isOpen: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLHeadingElement;
+};
+
+declare function __VLS_template_30(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_31(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_32(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_33(): {
+    attrs: Partial<{}>;
+    slots: {
+        left?(_: {}): any;
+        right?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_34(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        dialogRef: HTMLDialogElement;
+    };
+    rootEl: HTMLDialogElement;
+};
+
+declare function __VLS_template_35(): {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {
+            open: boolean;
+            toggle: typeof toggle;
+            close: typeof close_3;
+        }): any;
+        default?(_: {
+            close: typeof close_3;
+        }): any;
+    };
+    refs: {
+        triggerRef: HTMLDivElement;
+        popoverRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_36(): {
+    attrs: Partial<{}>;
+    slots: {
+        sidebar?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_37(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+
+declare function __VLS_template_38(): {
+    attrs: Partial<{}>;
+    slots: {
+        badge?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_39(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_4(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_40(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_41(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_42(): {
+    attrs: Partial<{}>;
+    slots: {
+        indicator?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+
+declare function __VLS_template_43(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_44(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<NonNullable<string | number>, (_: {}) => any>>;
+    refs: {
+        tabListRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_45(): {
+    attrs: Partial<{}>;
+    slots: {
+        left?(_: {}): any;
+    };
+    refs: {
+        textareaRef: HTMLTextAreaElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_46(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_47(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_48(): {
+    attrs: Partial<{}>;
+    slots: {
+        dot?(_: {}): any;
+        default?(_: {}): any;
+        opposite?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_49(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+
+declare function __VLS_template_5(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+
+declare function __VLS_template_50(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_51(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLSpanElement;
+        contentRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_52(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_53(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_54(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_55(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_56(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_57(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_6(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        badge?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+
+declare function __VLS_template_7(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?(): unknown;
+        separator?(): unknown;
+    }> & {
+        default?(): unknown;
+        separator?(): unknown;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+
+declare function __VLS_template_8(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLOListElement;
+};
+
+declare function __VLS_template_9(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_10 = ReturnType<typeof __VLS_template_10>;
+
+declare type __VLS_TemplateResult_11 = ReturnType<typeof __VLS_template_11>;
+
+declare type __VLS_TemplateResult_12 = ReturnType<typeof __VLS_template_12>;
+
+declare type __VLS_TemplateResult_13 = ReturnType<typeof __VLS_template_13>;
+
+declare type __VLS_TemplateResult_14 = ReturnType<typeof __VLS_template_14>;
+
+declare type __VLS_TemplateResult_15 = ReturnType<typeof __VLS_template_15>;
+
+declare type __VLS_TemplateResult_16 = ReturnType<typeof __VLS_template_16>;
+
+declare type __VLS_TemplateResult_17 = ReturnType<typeof __VLS_template_17>;
+
+declare type __VLS_TemplateResult_18 = ReturnType<typeof __VLS_template_18>;
+
+declare type __VLS_TemplateResult_19 = ReturnType<typeof __VLS_template_19>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
+
+declare type __VLS_TemplateResult_20 = ReturnType<typeof __VLS_template_20>;
+
+declare type __VLS_TemplateResult_21 = ReturnType<typeof __VLS_template_21>;
+
+declare type __VLS_TemplateResult_22 = ReturnType<typeof __VLS_template_22>;
+
+declare type __VLS_TemplateResult_23 = ReturnType<typeof __VLS_template_23>;
+
+declare type __VLS_TemplateResult_24 = ReturnType<typeof __VLS_template_24>;
+
+declare type __VLS_TemplateResult_25 = ReturnType<typeof __VLS_template_25>;
+
+declare type __VLS_TemplateResult_26 = ReturnType<typeof __VLS_template_26>;
+
+declare type __VLS_TemplateResult_27 = ReturnType<typeof __VLS_template_27>;
+
+declare type __VLS_TemplateResult_28 = ReturnType<typeof __VLS_template_28>;
+
+declare type __VLS_TemplateResult_29 = ReturnType<typeof __VLS_template_29>;
+
+declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
+
+declare type __VLS_TemplateResult_30 = ReturnType<typeof __VLS_template_30>;
+
+declare type __VLS_TemplateResult_31 = ReturnType<typeof __VLS_template_31>;
+
+declare type __VLS_TemplateResult_32 = ReturnType<typeof __VLS_template_32>;
+
+declare type __VLS_TemplateResult_33 = ReturnType<typeof __VLS_template_33>;
+
+declare type __VLS_TemplateResult_34 = ReturnType<typeof __VLS_template_34>;
+
+declare type __VLS_TemplateResult_35 = ReturnType<typeof __VLS_template_35>;
+
+declare type __VLS_TemplateResult_36 = ReturnType<typeof __VLS_template_36>;
+
+declare type __VLS_TemplateResult_37 = ReturnType<typeof __VLS_template_37>;
+
+declare type __VLS_TemplateResult_38 = ReturnType<typeof __VLS_template_38>;
+
+declare type __VLS_TemplateResult_39 = ReturnType<typeof __VLS_template_39>;
+
+declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;
+
+declare type __VLS_TemplateResult_40 = ReturnType<typeof __VLS_template_40>;
+
+declare type __VLS_TemplateResult_41 = ReturnType<typeof __VLS_template_41>;
+
+declare type __VLS_TemplateResult_42 = ReturnType<typeof __VLS_template_42>;
+
+declare type __VLS_TemplateResult_43 = ReturnType<typeof __VLS_template_43>;
+
+declare type __VLS_TemplateResult_44 = ReturnType<typeof __VLS_template_44>;
+
+declare type __VLS_TemplateResult_45 = ReturnType<typeof __VLS_template_45>;
+
+declare type __VLS_TemplateResult_46 = ReturnType<typeof __VLS_template_46>;
+
+declare type __VLS_TemplateResult_47 = ReturnType<typeof __VLS_template_47>;
+
+declare type __VLS_TemplateResult_48 = ReturnType<typeof __VLS_template_48>;
+
+declare type __VLS_TemplateResult_49 = ReturnType<typeof __VLS_template_49>;
+
+declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;
+
+declare type __VLS_TemplateResult_50 = ReturnType<typeof __VLS_template_50>;
+
+declare type __VLS_TemplateResult_51 = ReturnType<typeof __VLS_template_51>;
+
+declare type __VLS_TemplateResult_52 = ReturnType<typeof __VLS_template_52>;
+
+declare type __VLS_TemplateResult_53 = ReturnType<typeof __VLS_template_53>;
+
+declare type __VLS_TemplateResult_54 = ReturnType<typeof __VLS_template_54>;
+
+declare type __VLS_TemplateResult_55 = ReturnType<typeof __VLS_template_55>;
+
+declare type __VLS_TemplateResult_56 = ReturnType<typeof __VLS_template_56>;
+
+declare type __VLS_TemplateResult_57 = ReturnType<typeof __VLS_template_57>;
+
+declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;
+
+declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;
+
+declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;
+
+declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_10<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_11<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_12<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_13<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_14<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_15<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_16<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_17<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_18<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_19<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_20<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_21<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_22<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_23<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_24<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_25<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_26<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_27<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_28<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_29<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_30<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_31<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_32<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_33<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_34<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_35<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_36<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_37<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_38<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_39<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_4<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_40<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_41<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_42<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_43<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_44<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_45<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_46<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_47<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_48<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_49<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_5<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_50<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_51<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_52<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_53<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_54<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_55<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_56<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_57<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_58<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_59<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_6<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_60<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_7<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_8<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_9<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const AccordionContent: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
+
+declare interface AccordionContentProps {
+    /** Lazy render - use v-if instead of v-show. Better performance but breaks Ctrl+F search. */
+    lazy?: boolean;
+}
+
+export declare const AccordionItem: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+export declare interface AccordionItemProps {
+    /** Unique identifier for this item */
+    value: string;
+    /** Disable this item */
+    disabled?: boolean;
+}
+
+export declare const AccordionRoot: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare interface AccordionRootProps {
+    /** Currently open item(s) - single value or array for multiple mode */
+    modelValue?: string | string[];
+    /** Allow all items to be collapsed */
+    collapsible?: boolean;
+    /** Allow multiple items open simultaneously */
+    multiple?: boolean;
+    /** Visual variant */
+    variant?: AccordionVariant;
+}
+
+export declare const AccordionTrigger: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
+
+export declare interface AccordionTriggerProps {
+    /** Hide the default chevron indicator */
+    hideIndicator?: boolean;
+}
+
+declare type AccordionVariant = 'contained' | 'split';
+
+declare function applyPreset(startDate: Date, endDate: Date): void;
+
+export declare const Avatar: DefineComponent<AvatarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarProps> & Readonly<{}>, {
+variant: AvatarVariant;
+size: AvatarSize;
+shape: AvatarShape;
+bordered: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface AvatarProps {
+    /** Image source URL */
+    src?: string;
+    /** User name - used for alt text AND initials fallback */
+    name?: string;
+    /** Override alt text (defaults to name) */
+    alt?: string;
+    /** Avatar size */
+    size?: AvatarSize;
+    /** Avatar shape */
+    shape?: AvatarShape;
+    /** Background variant when showing initials/icon */
+    variant?: AvatarVariant;
+    /** Add border for avatar groups (cutout effect) */
+    bordered?: boolean;
+}
+
+declare type AvatarShape = 'circle' | 'square';
+
+declare type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+declare type AvatarVariant = 'neutral' | 'primary' | 'soft';
+
+export declare const Badge: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;
+
+export declare const BadgeContainer: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;
+
+export declare interface BadgeContainerProps {
+    /** Badge position relative to content */
+    position?: BadgePosition;
+    /** Horizontal offset adjustment (CSS value) */
+    offsetX?: string;
+    /** Vertical offset adjustment (CSS value) */
+    offsetY?: string;
+    /** Show cutout border matching background */
+    cutout?: boolean;
+}
+
+declare type BadgePosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+
+export declare interface BadgeProps {
+    /** Color variant */
+    variant?: BadgeVariant;
+    /** Render as dot indicator instead of pill */
+    dot?: boolean;
+    /** Add pulse animation (dot mode only) */
+    pulse?: boolean;
+    /** Numeric value for count badges */
+    value?: number;
+    /** Max value before showing "+" (default: 99) */
+    max?: number;
+    /** Accessible label (required for numeric badges) */
+    label?: string;
+}
+
+declare type BadgeVariant = 'default' | 'success' | 'warning' | 'danger' | 'info';
+
+export declare const BarChart: __VLS_WithTemplateSlots_22<typeof __VLS_component_22, __VLS_TemplateResult_22["slots"]>;
+
+export declare interface BarChartProps {
+    /** X-axis labels */
+    labels: string[];
+    /** Data series */
+    series: BarChartSeries[];
+    /** Chart height */
+    height?: string | number;
+    /** Horizontal bar orientation */
+    horizontal?: boolean;
+    /** Stack bars on top of each other */
+    stacked?: boolean;
+    /** Bar border radius */
+    borderRadius?: number;
+    /** Show grid lines */
+    showGrid?: boolean;
+    /** Show X axis */
+    showXAxis?: boolean;
+    /** Show Y axis */
+    showYAxis?: boolean;
+    /** Accessible label */
+    ariaLabel?: string;
+    /** Show built-in legend */
+    showLegend?: boolean;
+}
+
+export declare interface BarChartSeries {
+    name: string;
+    data: number[];
+}
+
+export declare const BaseChart: __VLS_WithTemplateSlots_20<typeof __VLS_component_20, __VLS_TemplateResult_20["slots"]>;
+
+export declare interface BaseChartProps {
+    /** Chart type (line, bar, doughnut, pie, etc.) */
+    type: ChartType;
+    /** Chart.js data configuration */
+    data: ChartData | Record<string, unknown>;
+    /** Chart.js options configuration */
+    options?: ChartOptions | Record<string, unknown>;
+    /** Chart height */
+    height?: string | number;
+    /** Accessible label for screen readers */
+    ariaLabel?: string;
+}
+
+export declare interface BreadcrumbContext {
+    separator: Component | string | (() => VNode);
+}
+
+export declare const BreadcrumbEllipsis: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, __VLS_TemplateResult_13["slots"]>;
+
+export declare interface BreadcrumbEllipsisItem {
+    /** Display label */
+    label: string;
+    /** URL for standard anchor */
+    href?: string;
+    /** Route location for vue-router (string or route object) */
+    to?: string | Record<string, unknown>;
+}
+
+export declare interface BreadcrumbEllipsisProps {
+    /** Hidden breadcrumb items to show in dropdown */
+    items?: BreadcrumbEllipsisItem[];
+}
+
+export declare const BreadcrumbItem: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;
+
+export declare const BreadcrumbLink: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;
+
+export declare interface BreadcrumbLinkProps {
+    /** URL for standard anchor */
+    href?: string;
+    /** Route location for vue-router (string or route object) */
+    to?: string | Record<string, unknown>;
+    /** Custom component to render as */
+    as?: string | Component;
+}
+
+export declare const BreadcrumbList: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
+
+export declare const BreadcrumbPage: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;
+
+export declare const BreadcrumbRoot: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;
+
+export declare interface BreadcrumbRootProps {
+    /** Custom separator component or string */
+    separator?: Component | string | (() => VNode);
+}
+
+export declare const BreadcrumbSeparator: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;
+
+export declare const Button: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, __VLS_TemplateResult_14["slots"]>;
+
+export declare interface ButtonProps {
+    /** Visual style variant */
+    variant?: 'primary' | 'secondary' | 'destructive' | 'ghost' | 'outline';
+    /** Button size */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Render as different element or component (e.g., router-link) */
+    as?: string | Component;
+    /** Show loading spinner and disable interactions */
+    loading?: boolean;
+    /** Disable button */
+    disabled?: boolean;
+    /** Icon to show before text (any format supported by Icon component) */
+    iconLeft?: IconInput;
+    /** Icon to show after text (any format supported by Icon component) */
+    iconRight?: IconInput;
+    /** Make button full width */
+    block?: boolean;
+    /** Button type attribute */
+    type?: 'button' | 'submit' | 'reset';
+}
+
+/**
+ * Calendar grid item representing a single day cell.
+ */
+export declare interface CalendarDay {
+    /** The date object for this cell */
+    date: Date;
+    /** Day of the month (1-31) */
+    day: number;
+    /** Whether this day belongs to the currently viewed month */
+    currentMonth: boolean;
+}
+
+export declare const Callout: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;
+
+export declare interface CalloutProps {
+    /** Visual variant determining color and icon */
+    variant?: CalloutVariant;
+    /** Title text (alternative to #title slot) */
+    title?: string;
+    /** Show left accent border instead of full border */
+    accent?: boolean;
+    /** Show dismiss button */
+    dismissible?: boolean;
+    /** Hide the default icon */
+    hideIcon?: boolean;
+}
+
+export declare type CalloutVariant = 'info' | 'success' | 'warning' | 'error' | 'neutral';
+
+export declare const Card: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;
+
+export declare const CardContent: __VLS_WithTemplateSlots_18<typeof __VLS_component_18, __VLS_TemplateResult_18["slots"]>;
+
+export declare interface CardContentProps {
+    /** Remove default padding */
+    flush?: boolean;
+}
+
+export declare const CardFooter: __VLS_WithTemplateSlots_19<typeof __VLS_component_19, __VLS_TemplateResult_19["slots"]>;
+
+export declare interface CardFooterProps {
+    /** Content alignment */
+    align?: 'start' | 'center' | 'end' | 'between';
+    /** Remove separator border */
+    borderless?: boolean;
+}
+
+export declare const CardHeader: __VLS_WithTemplateSlots_17<typeof __VLS_component_17, __VLS_TemplateResult_17["slots"]>;
+
+export declare interface CardHeaderProps {
+    /** Title text (alternative to slot) */
+    title?: string;
+    /** Subtitle text (alternative to slot) */
+    subtitle?: string;
+    /** Aligns header content */
+    align?: 'start' | 'center';
+}
+
+export declare const CardImage: DefineComponent<CardImageProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardImageProps> & Readonly<{}>, {
+position: CardImagePosition;
+loading: "eager" | "lazy";
+aspectRatio: CardImageAspectRatio;
+fit: CardImageFit;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare type CardImageAspectRatio = '16:9' | '4:3' | '3:2' | '1:1' | 'auto';
+
+export declare type CardImageFit = 'cover' | 'contain' | 'fill';
+
+export declare type CardImagePosition = 'top' | 'bottom' | 'left' | 'right' | 'background';
+
+export declare interface CardImageProps {
+    /** Image source URL */
+    src: string;
+    /** Alt text for accessibility */
+    alt: string;
+    /** Aspect ratio constraint */
+    aspectRatio?: CardImageAspectRatio;
+    /** Image position within card */
+    position?: CardImagePosition;
+    /** Object-fit behavior */
+    fit?: CardImageFit;
+    /** Loading attribute for native lazy loading */
+    loading?: 'eager' | 'lazy';
+}
+
+export declare type CardPadding = 'none' | 'sm' | 'md' | 'lg';
+
+export declare interface CardProps {
+    /** Visual style variant */
+    variant?: CardVariant;
+    /** Render as different element (article, section, aside, etc.) */
+    as?: string | Component;
+    /** Makes the entire card clickable with overlay pattern */
+    interactive?: boolean;
+    /** Horizontal layout - image on side instead of top */
+    horizontal?: boolean;
+    /** Disabled state for interactive cards */
+    disabled?: boolean;
+    /** Loading state - shows skeleton overlay */
+    loading?: boolean;
+    /** Custom padding override */
+    padding?: CardPadding;
+}
+
+export declare type CardVariant = 'elevated' | 'outline' | 'ghost';
+
+export declare interface ChartDataset {
+    label?: string;
+    data: number[];
+    backgroundColor?: string | string[];
+    borderColor?: string | string[];
+    borderWidth?: number;
+    fill?: boolean | string;
+    tension?: number;
+}
+
+export declare interface ChartTheme {
+    colors: ChartThemeColors;
+    fontFamily: string;
+    palette: string[];
+}
+
+export declare interface ChartThemeColors {
+    primary: string;
+    success: string;
+    warning: string;
+    error: string;
+    info: string;
+    text: string;
+    textMuted: string;
+    gridLines: string;
+    tooltipBg: string;
+    tooltipText: string;
+    tooltipBorder: string;
+    legendText: string;
+}
+
+export declare const Checkbox: DefineComponent<CheckboxProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: boolean) => any;
+change: (value: boolean) => any;
+}, string, PublicProps, Readonly<CheckboxProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+onChange?: ((value: boolean) => any) | undefined;
+}>, {
+modelValue: boolean;
+size: "sm" | "md" | "lg";
+disabled: boolean;
+indeterminate: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+inputRef: HTMLInputElement;
+}, HTMLLabelElement>;
+
+export declare interface CheckboxProps {
+    /** Checked state (v-model) */
+    modelValue?: boolean;
+    /** Indeterminate state (partial selection) */
+    indeterminate?: boolean;
+    /** Checkbox size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Visible label text */
+    label?: string;
+    /** Description text below label */
+    description?: string;
+    /** HTML name for form submission */
+    name?: string;
+    /** Value attribute for form submission */
+    value?: string;
+    /** ID for label association */
+    id?: string;
+}
+
+export declare const ChoiceChip: DefineComponent<ChoiceChipProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: boolean) => any;
+change: (value: boolean) => any;
+}, string, PublicProps, Readonly<ChoiceChipProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+onChange?: ((value: boolean) => any) | undefined;
+}>, {
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLabelElement>;
+
+export declare const ChoiceChipGroup: __VLS_WithTemplateSlots_33<typeof __VLS_component_31, __VLS_TemplateResult_31["slots"]>;
+
+export declare interface ChoiceChipGroupProps {
+    /** Selected value(s) - single value for 'single' type, array for 'multiple' */
+    modelValue?: string | number | (string | number)[];
+    /** Selection type */
+    type?: 'single' | 'multiple';
+    /** Disabled state for all chips */
+    disabled?: boolean;
+    /** Accessible label for the group */
+    label?: string;
+}
+
+export declare interface ChoiceChipProps {
+    /** Selected state for standalone usage (v-model) */
+    modelValue?: boolean;
+    /** Value for group usage */
+    value?: string | number;
+    /** Chip label text */
+    label: string;
+    /** Optional leading icon */
+    icon?: IconInput;
+    /** Disabled state */
+    disabled?: boolean;
+}
+
+/**
+ * Clear all files
+ */
+declare function clearAll(): void;
+
+declare function close_2(): void;
+
+declare function close_3(): void;
+
+declare function closeCalendar(): void;
+
+export declare const ColorArea: DefineComponent<ColorAreaProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:saturation": (value: number) => any;
+"update:value": (value: number) => any;
+}, string, PublicProps, Readonly<ColorAreaProps> & Readonly<{
+"onUpdate:saturation"?: ((value: number) => any) | undefined;
+"onUpdate:value"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+areaRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+export declare interface ColorAreaProps {
+    /** Hue value (0-360) */
+    hue: number;
+    /** Saturation value (0-1) */
+    saturation: number;
+    /** Value/Brightness (0-1) */
+    value: number;
+}
+
+export declare type ColorFormat = 'hex' | 'rgb' | 'oklch';
+
+export declare const ColorPicker: DefineComponent<ColorPickerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<ColorPickerProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+disabled: boolean;
+alpha: boolean;
+format: ColorFormat;
+swatchOnly: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface ColorPickerProps {
+    /** Current color value */
+    modelValue: string;
+    /** Output format */
+    format?: ColorFormat;
+    /** Disable the picker */
+    disabled?: boolean;
+    /** Show only the swatch, hide text input */
+    swatchOnly?: boolean;
+    /** Show alpha channel slider */
+    alpha?: boolean;
+}
+
+export declare const ColorSlider: DefineComponent<ColorSliderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: number) => any;
+}, string, PublicProps, Readonly<ColorSliderProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+color: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+trackRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+export declare interface ColorSliderProps {
+    /** Current value (0-1 for alpha, 0-360 for hue) */
+    modelValue: number;
+    /** Slider type */
+    type: 'hue' | 'alpha';
+    /** Current color for alpha gradient (hex without alpha) */
+    color?: string;
+}
+
+export declare type ColumnAlign = 'left' | 'center' | 'right';
+
+export declare type ColumnCount = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+
+export declare const Combobox: DefineComponent<ComboboxProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number | (string | number)[] | null) => any;
+create: (value: string) => any;
+}, string, PublicProps, Readonly<ComboboxProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number | (string | number)[] | null) => any) | undefined;
+onCreate?: ((value: string) => any) | undefined;
+}>, {
+modelValue: string | number | (string | number)[] | null;
+multiple: boolean;
+size: "sm" | "md" | "lg";
+disabled: boolean;
+required: boolean;
+placeholder: string;
+block: boolean;
+allowCreate: boolean;
+maxDisplayedChips: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+containerRef: HTMLDivElement;
+inputRef: HTMLInputElement;
+listboxRef: HTMLUListElement;
+}, HTMLDivElement>;
+
+export declare interface ComboboxOption {
+    /** Display text shown to user */
+    label: string;
+    /** Value stored in v-model */
+    value: string | number;
+    /** Disable this option */
+    disabled?: boolean;
+}
+
+export declare interface ComboboxProps {
+    /** Selected value(s) - single value or array for multiple */
+    modelValue?: string | number | (string | number)[] | null;
+    /** Available options */
+    options: ComboboxOption[];
+    /** Enable multi-select mode */
+    multiple?: boolean;
+    /** Label text above input */
+    label?: string;
+    /** Placeholder when empty */
+    placeholder?: string;
+    /** Helper text below input */
+    hint?: string;
+    /** Error message (also sets error state) */
+    error?: string;
+    /** Input size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Required field */
+    required?: boolean;
+    /** Full width mode */
+    block?: boolean;
+    /** Allow creating new options (tagging) */
+    allowCreate?: boolean;
+    /** Max chips to display before +N (multi-select only) */
+    maxDisplayedChips?: number;
+    /** HTML id attribute */
+    id?: string;
+    /** HTML name attribute (for forms) */
+    name?: string;
+}
+
+/**
+ * Configure internal icons used by Spire UI components.
+ * Call this before mounting your app to customize icons globally.
+ *
+ * @example
+ * ```ts
+ * import { configureIcons } from 'spire-ui'
+ * import { ArrowUp, ArrowDown, X } from 'lucide-vue-next'
+ *
+ * configureIcons({
+ *   sortAsc: ArrowUp,
+ *   sortDesc: ArrowDown,
+ *   close: X
+ * })
+ * ```
+ */
+export declare function configureIcons(userIcons: Partial<IconMap>): void;
+
+export declare const Container: __VLS_WithTemplateSlots_57<typeof __VLS_component_54, __VLS_TemplateResult_54["slots"]>;
+
+export declare interface ContainerProps {
+    /** If true, width is 100%. If false, max-width snaps to breakpoints. */
+    fluid?: boolean;
+    /** Auto margins (mx-auto). Default: true */
+    centered?: boolean;
+    /** HTML tag to render */
+    as?: string;
+}
+
+export declare const DataTable: __VLS_WithTemplateSlots_24<typeof __VLS_component_24, __VLS_TemplateResult_24["slots"]>;
+
+export declare interface DataTableColumn {
+    /** Key path (supports dot notation: 'user.email') */
+    key: string;
+    /** Header label */
+    label: string;
+    /** Text alignment */
+    align?: ColumnAlign;
+    /** Fixed width (e.g., '80px') */
+    width?: string;
+    /** Minimum width for resizable columns */
+    minWidth?: string;
+    /** Enable sorting */
+    sortable?: boolean;
+    /** Enable filtering for this column */
+    filterable?: boolean;
+    /** Custom filter function */
+    filterFn?: FilterFn;
+    /** Enable resizing for this column */
+    resizable?: boolean;
+}
+
+export declare interface DataTableProps {
+    /** Data array */
+    data: Record<string, unknown>[];
+    /** Column definitions */
+    columns: DataTableColumn[];
+    /** Enable row selection */
+    selectable?: boolean;
+    /** Selected row IDs (v-model:selectedIds) */
+    selectedIds?: (string | number)[];
+    /** Row identifier key (default: 'id') */
+    rowKey?: string;
+    /** Loading state */
+    loading?: boolean;
+    /** Skeleton rows count (default: 5) */
+    skeletonRows?: number;
+    /** Striped rows */
+    striped?: boolean;
+    /** Row hover effect */
+    hoverable?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Empty state message */
+    emptyMessage?: string;
+    /** Show cell borders */
+    bordered?: boolean;
+    /** Sticky header */
+    stickyHeader?: boolean;
+    /** Enable pagination (boolean or config object) */
+    pagination?: boolean | PaginationConfig;
+    /** Current page for controlled pagination (v-model:page) */
+    page?: number;
+    /** Page size for controlled pagination (v-model:pageSize) */
+    pageSize?: number;
+    /** Total items count (required for server-side pagination) */
+    total?: number;
+    /** Server-side mode: disables client-side slicing, emits events for parent to handle */
+    serverSide?: boolean;
+    /** Enable global search */
+    searchable?: boolean;
+    /** Search query (v-model:search) */
+    search?: string;
+    /** Placeholder for search input */
+    searchPlaceholder?: string;
+    /** Enable column filters (shows filter inputs below headers) */
+    filterable?: boolean;
+    /** Current filter values (v-model:filters) */
+    filters?: Record<string, string>;
+    /** Enable column resizing */
+    resizable?: boolean;
+    /** Enable expandable rows */
+    expandable?: boolean;
+    /** Expanded row IDs (v-model:expandedIds) */
+    expandedIds?: (string | number)[];
+}
+
+export declare const DatePicker: __VLS_WithTemplateSlots_25<typeof __VLS_component_25, __VLS_TemplateResult_25["slots"]>;
+
+export declare interface DatePickerProps {
+    /** Selected date in ISO format (single mode) or [start, end] tuple (range mode) */
+    modelValue?: string | [string, string];
+    /** Selection mode */
+    mode?: 'single' | 'range';
+    /** Minimum selectable date in ISO format */
+    min?: string;
+    /** Maximum selectable date in ISO format */
+    max?: string;
+    /** Label text above the input */
+    label?: string;
+    /** Placeholder text when no date is selected */
+    placeholder?: string;
+    /** Helper text below input */
+    hint?: string;
+    /** Error message (also sets error state) */
+    error?: string;
+    /** Input size - matches Button/Input heights */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Required field indicator */
+    required?: boolean;
+    /** HTML id attribute */
+    id?: string;
+    /** HTML name attribute */
+    name?: string;
+    /** Make input full width */
+    block?: boolean;
+    /** Locale for month/day names (defaults to browser locale) */
+    locale?: string;
+    /** Format function for displaying the selected date */
+    formatDisplay?: (date: Date) => string;
+    /** Format function for displaying range (range mode only) */
+    formatRangeDisplay?: (start: Date, end: Date) => string;
+}
+
+export declare type DatePickerViewMode = 'day' | 'month' | 'year';
+
+export declare type Depth = 'flat' | 'subtle' | 'elevated' | 'dimensional';
+
+export declare const DonutChart: __VLS_WithTemplateSlots_23<typeof __VLS_component_23, __VLS_TemplateResult_23["slots"]>;
+
+export declare interface DonutChartProps {
+    /** Chart segments */
+    segments: DonutChartSegment[];
+    /** Chart height */
+    height?: string | number;
+    /** Donut cutout percentage (0-100, 0 = pie chart) */
+    cutout?: number;
+    /** Accessible label */
+    ariaLabel?: string;
+    /** Show built-in legend */
+    showLegend?: boolean;
+    /** Legend position */
+    legendPosition?: 'top' | 'bottom' | 'left' | 'right';
+    /** Center label (for donut charts) */
+    centerLabel?: string;
+    /** Center value (for donut charts) */
+    centerValue?: string;
+}
+
+export declare interface DonutChartSegment {
+    label: string;
+    value: number;
+    color?: string;
+}
+
+export declare const Drawer: __VLS_WithTemplateSlots_26<typeof __VLS_component_26, __VLS_TemplateResult_26["slots"]>;
+
+export declare type DrawerPlacement = 'right' | 'left' | 'bottom';
+
+export declare interface DrawerProps {
+    /** Controls visibility (v-model) */
+    modelValue?: boolean;
+    /** Drawer title */
+    title?: string;
+    /** Visual variant */
+    variant?: DrawerVariant;
+    /** Placement on desktop */
+    placement?: DrawerPlacement;
+    /** Width/height preset */
+    size?: DrawerSize;
+    /** Allow closing by clicking backdrop */
+    maskClosable?: boolean;
+    /** Allow closing with Escape key */
+    closeOnEscape?: boolean;
+    /** Show close button in header */
+    showClose?: boolean;
+}
+
+export declare type DrawerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+
+export declare type DrawerVariant = 'default' | 'floating';
+
+export declare const Dropdown: __VLS_WithTemplateSlots_27<DefineComponent<DropdownProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+close: () => any;
+open: () => any;
+}, string, PublicProps, Readonly<DropdownProps> & Readonly<{
+onClose?: (() => any) | undefined;
+onOpen?: (() => any) | undefined;
+}>, {
+disabled: boolean;
+placement: DropdownPlacement;
+offset: number;
+menuWidth: "auto" | "trigger" | number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+triggerRef: HTMLDivElement;
+menuRef: HTMLDivElement;
+}, HTMLDivElement>, {
+    trigger?(_: {
+        open: boolean;
+        toggle: () => void;
+    }): any;
+    default?(_: {}): any;
+}>;
+
+export declare interface DropdownContext {
+    close: () => void;
+    closeAll: () => void;
+    cancelClose: () => void;
+    registerItem: (el: HTMLElement) => void;
+    unregisterItem: (el: HTMLElement) => void;
+    registerSubmenu: (submenu: SubmenuRegistration) => void;
+    unregisterSubmenu: (id: string) => void;
+    isSubmenu: boolean;
+    depth: number;
+    isMobile: Ref<boolean>;
+    openSubmenuId: Ref<string | null>;
+    setOpenSubmenu: (id: string | null) => void;
+    safeTriangle: SafeTriangleState;
+    menuStack: Ref<string[]>;
+    pushMenu: (id: string, label: string) => void;
+    popMenu: () => void;
+}
+
+export declare const DropdownItem: __VLS_WithTemplateSlots_28<typeof __VLS_component_27, __VLS_TemplateResult_27["slots"]>;
+
+export declare interface DropdownItemProps {
+    /** Renders as RouterLink when provided */
+    to?: string | Record<string, unknown>;
+    /** Renders as anchor when provided */
+    href?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Danger/destructive styling */
+    danger?: boolean;
+    /** Leading icon */
+    icon?: Component;
+    /** Keyboard shortcut hint */
+    shortcut?: string;
+    /** Prevent menu from closing on click */
+    preventClose?: boolean;
+    /** Show chevron indicator (for submenu triggers) */
+    chevron?: boolean;
+}
+
+export declare type DropdownPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'left-start' | 'left-end';
+
+export declare interface DropdownProps {
+    /** Menu placement relative to trigger */
+    placement?: DropdownPlacement;
+    /** Offset from trigger (px) */
+    offset?: number;
+    /** Disable the dropdown */
+    disabled?: boolean;
+    /** Width of the menu ('auto', 'trigger', or px value) */
+    menuWidth?: 'auto' | 'trigger' | number;
+}
+
+export declare const DropdownSeparator: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+export declare const DropdownSub: __VLS_WithTemplateSlots_29<DefineComponent<    {}, {
+isOpen: Ref<boolean, boolean>;
+triggerRef: Ref<HTMLElement | null, HTMLElement | null>;
+contentRef: Ref<HTMLElement | null, HTMLElement | null>;
+open: () => void;
+close: () => void;
+scheduleClose: () => void;
+cancelClose: () => void;
+onContentKeydown: (e: KeyboardEvent) => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>, {
+    default?(_: {}): any;
+}>;
+
+export declare const DropdownSubContent: __VLS_WithTemplateSlots_31<typeof __VLS_component_29, __VLS_TemplateResult_29["slots"]>;
+
+export declare interface DropdownSubContext {
+    isOpen: {
+        value: boolean;
+    };
+    triggerRef: {
+        value: HTMLElement | null;
+    };
+    open: () => void;
+    close: () => void;
+    onTriggerKeydown: (e: KeyboardEvent) => void;
+    scheduleClose: () => void;
+    cancelClose: () => void;
+}
+
+export declare const DropdownSubTrigger: __VLS_WithTemplateSlots_30<typeof __VLS_component_28, __VLS_TemplateResult_28["slots"]>;
+
+export declare interface DropdownSubTriggerProps {
+    /** Disabled state */
+    disabled?: boolean;
+    /** Leading icon */
+    icon?: Component;
+}
+
+export declare const EmptyState: __VLS_WithTemplateSlots_32<typeof __VLS_component_30, __VLS_TemplateResult_30["slots"]>;
+
+export declare interface EmptyStateProps {
+    /** Title text */
+    title?: string;
+    /** Description text */
+    description?: string;
+    /** Custom icon to display (overrides variant icon) */
+    icon?: IconInput;
+    /** Visual variant */
+    variant?: EmptyStateVariant;
+    /** Compact mode with reduced padding */
+    compact?: boolean;
+}
+
+export declare type EmptyStateVariant = 'default' | 'search' | 'error';
+
+declare type EventTarget_2 = Window | Document | HTMLElement | null;
+
+export declare const FileUpload: DefineComponent<FileUploadProps, {
+updateProgress: typeof updateProgress;
+markSuccess: typeof markSuccess;
+markError: typeof markError;
+clearAll: typeof clearAll;
+triggerInput: typeof triggerInput;
+replaceFile: typeof replaceFile;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (files: UploadFile[]) => any;
+"files-added": (files: UploadFile[]) => any;
+"file-removed": (file: UploadFile) => any;
+"file-rejected": (file: File, reason: string) => any;
+"files-pasted": (files: UploadFile[]) => any;
+"file-replaced": (oldFile: UploadFile, newFile: UploadFile) => any;
+}, string, PublicProps, Readonly<FileUploadProps> & Readonly<{
+"onUpdate:modelValue"?: ((files: UploadFile[]) => any) | undefined;
+"onFiles-added"?: ((files: UploadFile[]) => any) | undefined;
+"onFile-removed"?: ((file: UploadFile) => any) | undefined;
+"onFile-rejected"?: ((file: File, reason: string) => any) | undefined;
+"onFiles-pasted"?: ((files: UploadFile[]) => any) | undefined;
+"onFile-replaced"?: ((oldFile: UploadFile, newFile: UploadFile) => any) | undefined;
+}>, {
+modelValue: UploadFile[];
+multiple: boolean;
+disabled: boolean;
+compact: boolean;
+showPreviews: boolean;
+allowPaste: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+dropzoneRef: HTMLDivElement;
+inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+
+export declare interface FileUploadProps {
+    /** Currently selected files (v-model) */
+    modelValue?: UploadFile[];
+    /** Accepted file types (MIME types or extensions) */
+    accept?: string;
+    /** Allow multiple file selection */
+    multiple?: boolean;
+    /** Maximum file size in bytes */
+    maxSize?: number;
+    /** Maximum number of files */
+    maxFiles?: number;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Label text */
+    label?: string;
+    /** Hint text */
+    hint?: string;
+    /** Error message */
+    error?: string;
+    /** Show image previews */
+    showPreviews?: boolean;
+    /** Compact mode (smaller dropzone) */
+    compact?: boolean;
+    /** Enable paste-to-upload (Ctrl+V) */
+    allowPaste?: boolean;
+}
+
+export declare type FilterFn = (value: unknown, filterValue: string, row: Record<string, unknown>) => boolean;
+
+export declare function formatColor(hsv: HSV, alpha: number, format: 'hex' | 'rgb' | 'oklch'): string;
+
+/**
+ * Format a Date object to ISO 8601 date string (YYYY-MM-DD).
+ *
+ * @param date - Date object to format
+ * @returns ISO date string in YYYY-MM-DD format
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function formatDate(date: Date): string;
+
+export declare function formatOklch(oklch: OKLCH, alpha?: number): string;
+
+export declare function formatRgb(rgb: RGB, alpha?: number): string;
+
+/**
+ * Formats hours and minutes into a time string.
+ * @param hours - Hour value (0-23)
+ * @param minutes - Minute value (0-59)
+ * @param format - Output format ('12h' or '24h')
+ */
+export declare function formatTime(hours: number, minutes: number, format?: TimeFormat): string;
+
+/**
+ * Generate a 42-item grid (6 rows × 7 columns) for a calendar month view.
+ * The grid always starts on Sunday and includes days from previous/next months
+ * to fill the complete 6-row layout.
+ *
+ * @param year - Full year (e.g., 2024)
+ * @param month - Month (0-11, where 0 = January)
+ * @returns Array of 42 CalendarDay objects
+ *
+ * Time complexity: O(1) - Fixed 42 iterations
+ * Space complexity: O(1) - Fixed 42-element array
+ */
+export declare function generateCalendarGrid(year: number, month: number): CalendarDay[];
+
+/**
+ * Generates an array of page numbers and ellipsis markers for pagination display.
+ *
+ * Time complexity: O(n) where n is siblingCount
+ * Space complexity: O(n) for the result array
+ *
+ * @param currentPage - The currently active page (1-indexed)
+ * @param totalPages - Total number of pages
+ * @param siblingCount - Number of pages to show on each side of current page
+ * @param showEdges - Whether to always show first and last page numbers
+ * @returns Array of page numbers and 'ellipsis' markers
+ */
+export declare function generatePageRange(currentPage: number, totalPages: number, siblingCount?: number, showEdges?: boolean): PageItem[];
+
+/**
+ * Generates an array of numbers within a range with optional step.
+ * Used for generating hour (0-23 or 1-12) and minute (0-59) options.
+ */
+export declare function generateRange(start: number, end: number, step?: number): number[];
+
+/**
+ * Generate a 20-year window centered around a given year for year grid view.
+ *
+ * @param centerYear - Year to center the window around
+ * @returns Array of 20 years [start, start+1, ..., start+19]
+ *
+ * Time complexity: O(1) - Fixed 20 iterations
+ * Space complexity: O(1) - Fixed 20-element array
+ */
+export declare function generateYearGrid(centerYear: number): number[];
+
+/**
+ * Get the number of days in a given month, correctly handling leap years.
+ *
+ * @param year - Full year (e.g., 2024)
+ * @param month - Month (0-11, where 0 = January)
+ * @returns Number of days in the month (28-31)
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function getDaysInMonth(year: number, month: number): number;
+
+/**
+ * Extract initials from a name string.
+ *
+ * @param name - Full name (e.g., "John Doe", "Madonna", "John von Doe")
+ * @param limit - Maximum characters to return (default: 2)
+ * @returns Uppercase initials (e.g., "JD", "M", "JD")
+ *
+ * @example
+ * getInitials("John Doe")      // "JD"
+ * getInitials("Madonna")       // "MA"
+ * getInitials("John von Doe")  // "JD" (first + last)
+ * getInitials("")              // ""
+ */
+export declare function getInitials(name?: string, limit?: number): string;
+
+/**
+ * Get localized month name.
+ *
+ * @param month - Month (0-11)
+ * @param locale - Locale string (defaults to browser locale)
+ * @returns Localized month name
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function getMonthName(month: number, locale?: string): string;
+
+/**
+ * Get all month names for a locale (short format for month grid).
+ *
+ * @param locale - Locale string (defaults to browser locale)
+ * @returns Array of 12 short month names
+ *
+ * Time complexity: O(1) - Fixed 12 iterations
+ * Space complexity: O(1) - Fixed 12-element array
+ */
+export declare function getMonthNamesShort(locale?: string): string[];
+
+/**
+ * Access a nested property in an object using dot notation.
+ *
+ * @param obj - The object to access
+ * @param path - Dot-notation path (e.g., 'user.email', 'address.city')
+ * @returns The value at the path, or undefined if not found
+ *
+ * @example
+ * getNestedValue({ user: { email: 'a@b.com' } }, 'user.email') // 'a@b.com'
+ * getNestedValue({ name: 'John' }, 'name') // 'John'
+ * getNestedValue({}, 'missing.path') // undefined
+ */
+export declare function getNestedValue(obj: Record<string, unknown>, path: string): unknown;
+
+/**
+ * Get the start of a date range preset.
+ *
+ * @param preset - Preset name
+ * @returns [start, end] date tuple
+ */
+export declare function getPresetRange(preset: string): [Date, Date];
+
+/**
+ * Determine the CSS class for a date in range selection mode.
+ * Handles the "flip" when user selects end date before start date.
+ *
+ * @param date - Date to classify
+ * @param start - Selected start date (or first click)
+ * @param end - Selected end date (or null if selecting)
+ * @param hover - Currently hovered date (for preview during selection)
+ * @returns Range class for styling
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function getRangeClass(date: Date, start: Date | null, end: Date | null, hover: Date | null): RangeClass;
+
+/**
+ * Convenience function to apply stagger animation styles directly via CSS.
+ * Returns a style object that can be applied to list items.
+ *
+ * @param index - Item index in the list
+ * @param options - Animation configuration
+ * @returns Style object with animation delay
+ *
+ * @example
+ * ```vue
+ * <template>
+ *   <ul>
+ *     <li
+ *       v-for="(item, index) in items"
+ *       :key="item.id"
+ *       :style="getStaggerStyle(index)"
+ *       class="stagger-item"
+ *     >
+ *       {{ item.name }}
+ *     </li>
+ *   </ul>
+ * </template>
+ *
+ * <style>
+ * .stagger-item {
+ *   animation: stagger-in var(--duration-normal) var(--ease-out) both;
+ *   animation-delay: var(--stagger-delay);
+ * }
+ * </style>
+ * ```
+ */
+export declare function getStaggerStyle(index: number, options?: {
+    delay?: number;
+}): Record<string, string>;
+
+/**
+ * Get localized weekday abbreviations starting from Sunday.
+ *
+ * @param locale - Locale string (defaults to browser locale)
+ * @returns Array of 7 weekday abbreviations
+ *
+ * Time complexity: O(1) - Fixed 7 iterations
+ * Space complexity: O(1) - Fixed 7-element array
+ */
+export declare function getWeekdayNames(locale?: string): string[];
+
+export declare const Grid: __VLS_WithTemplateSlots_59<typeof __VLS_component_56, __VLS_TemplateResult_56["slots"]>;
+
+export declare const GridItem: __VLS_WithTemplateSlots_60<typeof __VLS_component_57, __VLS_TemplateResult_57["slots"]>;
+
+export declare interface GridItemProps {
+    /** Number of columns to span (or responsive object) */
+    span?: SpanCount | ResponsiveSpan;
+    /** Grid column start */
+    start?: number;
+    /** Grid column end */
+    end?: number;
+    /** Grid row span */
+    rowSpan?: number;
+    /** HTML tag to render */
+    as?: string;
+}
+
+export declare interface GridProps {
+    /** Number of columns (or responsive object) */
+    columns?: ColumnCount | ResponsiveColumns;
+    /** Grid gap using spacing tokens */
+    gap?: SpacingToken;
+    /** Column gap override */
+    gapX?: SpacingToken;
+    /** Row gap override */
+    gapY?: SpacingToken;
+    /** HTML tag to render */
+    as?: string;
+}
+
+export declare const Heading: __VLS_WithTemplateSlots_34<typeof __VLS_component_32, __VLS_TemplateResult_32["slots"]>;
+
+export declare interface HeadingProps {
+    /** Semantic HTML tag */
+    as?: HeadingTag;
+    /** Visual hierarchy size */
+    size?: HeadingSize;
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Prevent wrapping with ellipsis */
+    truncate?: boolean;
+}
+
+declare type HeadingSize = '4xl' | '3xl' | '2xl' | 'xl' | 'lg' | 'md';
+
+declare type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'div' | 'span';
+
+export declare function hexToHsv(hex: string): HSV;
+
+export declare function hexToRgb(hex: string): RGB;
+
+export declare interface HSV {
+    h: number;
+    s: number;
+    v: number;
+}
+
+export declare interface HSVA extends HSV {
+    a: number;
+}
+
+export declare function hsvToHex(hsv: HSV): string;
+
+export declare function hsvToOklch(hsv: HSV): OKLCH;
+
+export declare function hsvToRgb(hsv: HSV): RGB;
+
+declare type HugeIconData = [string, Record<string, unknown>][];
+
+declare type HugeIconData_2 = [string, Record<string, unknown>][];
+
+export declare const Icon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<IconProps> & Readonly<{}>, {
+size: "xs" | "sm" | "md" | "lg" | "xl" | string;
+strokeWidth: number | string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare type IconInput = Component | HugeIconData;
+
+declare type IconInput_2 = Component | HugeIconData_2;
+
+/**
+ * Semantic icon keys used internally by Spire UI components.
+ * Components request icons by function, not by name.
+ */
+export declare interface IconMap {
+    sortAsc: Component;
+    sortDesc: Component;
+    sortNeutral: Component;
+    expand: Component;
+    collapse: Component;
+    close: Component;
+    search: Component;
+    check: Component;
+    info: Component;
+    success: Component;
+    warning: Component;
+    error: Component;
+    emptyData: Component;
+    emptySearch: Component;
+    calendar: Component;
+    chevronLeft: Component;
+    chevronRight: Component;
+    star: Component;
+    starFilled: Component;
+}
+
+export declare interface IconProps {
+    /** The icon - Vue component OR HugeIcons data array */
+    icon: IconInput;
+    /** Predefined size or custom value */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | string;
+    /** Stroke width (for stroke-based icons like Lucide) */
+    strokeWidth?: number | string;
+    /** Accessible label - required for standalone icons */
+    label?: string;
+}
+
+export declare const Input: __VLS_WithTemplateSlots_35<typeof __VLS_component_33, __VLS_TemplateResult_33["slots"]>;
+
+export declare interface InputProps {
+    /** Input value (v-model) */
+    modelValue?: string | number;
+    /** Input type */
+    type?: 'text' | 'email' | 'password' | 'search' | 'tel' | 'url' | 'number';
+    /** Label text above the input */
+    label?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Helper text below input */
+    hint?: string;
+    /** Error message (also sets error state) */
+    error?: string;
+    /** Input size - matches Button heights */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Read-only state */
+    readonly?: boolean;
+    /** Loading state - shows spinner */
+    loading?: boolean;
+    /** Required field */
+    required?: boolean;
+    /** Icon on the left side */
+    iconLeft?: IconInput;
+    /** Icon on the right side */
+    iconRight?: IconInput;
+    /** HTML id attribute (auto-generated if not provided) */
+    id?: string;
+    /** HTML name attribute */
+    name?: string;
+    /** Autocomplete attribute */
+    autocomplete?: InputHTMLAttributes['autocomplete'];
+    /** Make input full width */
+    block?: boolean;
+}
+
+/**
+ * Check if a date is after another date (day-level comparison).
+ *
+ * @param date - Date to check
+ * @param reference - Reference date
+ * @returns True if date is after reference
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function isDateAfter(date: Date, reference: Date): boolean;
+
+/**
+ * Check if a date is before another date (day-level comparison).
+ *
+ * @param date - Date to check
+ * @param reference - Reference date
+ * @returns True if date is before reference
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function isDateBefore(date: Date, reference: Date): boolean;
+
+/**
+ * Check if a date falls strictly between two dates (exclusive).
+ *
+ * @param date - Date to check
+ * @param start - Range start date
+ * @param end - Range end date
+ * @returns True if date is between start and end (exclusive)
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function isDateBetween(date: Date, start: Date | null, end: Date | null): boolean;
+
+/**
+ * Check if a date falls within an optional min/max range.
+ *
+ * @param date - Date to check
+ * @param min - Minimum allowed date (inclusive)
+ * @param max - Maximum allowed date (inclusive)
+ * @returns True if date is within range or no constraints exist
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function isDateInRange(date: Date, min?: Date | null, max?: Date | null): boolean;
+
+/**
+ * Check if two dates represent the same calendar day (ignoring time).
+ *
+ * @param d1 - First date
+ * @param d2 - Second date
+ * @returns True if both dates are the same day
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function isSameDate(d1: Date | null, d2: Date | null): boolean;
+
+/**
+ * Validates if a string is a valid time format (HH:mm)
+ */
+export declare function isValidTimeString(value: string): boolean;
+
+export declare interface LegendItem {
+    label: string;
+    color: string;
+    hidden: boolean;
+    datasetIndex: number;
+}
+
+export declare const LineChart: __VLS_WithTemplateSlots_21<typeof __VLS_component_21, __VLS_TemplateResult_21["slots"]>;
+
+export declare interface LineChartProps {
+    /** X-axis labels */
+    labels: string[];
+    /** Data series */
+    series: LineChartSeries[];
+    /** Chart height */
+    height?: string | number;
+    /** Show area fill under lines */
+    fill?: boolean;
+    /** Line curve tension (0 = straight, 0.4 = smooth) */
+    tension?: number;
+    /** Show points on the line */
+    showPoints?: boolean;
+    /** Point radius */
+    pointRadius?: number;
+    /** Show grid lines */
+    showGrid?: boolean;
+    /** Show X axis */
+    showXAxis?: boolean;
+    /** Show Y axis */
+    showYAxis?: boolean;
+    /** Accessible label */
+    ariaLabel?: string;
+    /** Show built-in legend */
+    showLegend?: boolean;
+}
+
+export declare interface LineChartSeries {
+    name: string;
+    data: number[];
+}
+
+/**
+ * Mark file as failed
+ */
+declare function markError(fileId: string, error: string): void;
+
+/**
+ * Mark file as successfully uploaded
+ */
+declare function markSuccess(fileId: string): void;
+
+declare type MaybeRef<T> = T | Ref<T>;
+
+export declare const Modal: __VLS_WithTemplateSlots_36<typeof __VLS_component_34, __VLS_TemplateResult_34["slots"]>;
+
+export declare interface ModalProps {
+    /** Controls visibility (v-model) */
+    modelValue?: boolean;
+    /** Optional header title */
+    title?: string;
+    /** Modal size */
+    size?: ModalSize;
+    /** Prevents closing via backdrop click or Escape key */
+    persistent?: boolean;
+}
+
+export declare type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+
+export declare type Mood = 'warm' | 'cool' | 'vibrant' | 'muted' | 'earthy';
+
+export declare type Motion = 'minimal' | 'smooth' | 'spring' | 'snappy';
+
+/**
+ * Normalize a range to ensure start <= end.
+ *
+ * @param start - First selected date
+ * @param end - Second selected date
+ * @returns Tuple [start, end] in chronological order
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function normalizeRange(start: Date, end: Date): [Date, Date];
+
+export declare interface OKLCH {
+    l: number;
+    c: number;
+    h: number;
+}
+
+export declare function oklchToHsv(oklch: OKLCH): HSV;
+
+export declare function oklchToRgb(oklch: OKLCH): RGB;
+
+declare function open_2(): void;
+
+declare function openCalendar(): void;
+
+export declare type PageItem = number | 'ellipsis';
+
+export declare const Pagination: DefineComponent<PaginationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: number) => any;
+}, string, PublicProps, Readonly<PaginationProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+size: "sm" | "md" | "lg";
+disabled: boolean;
+pageSize: number;
+siblingCount: number;
+showEdges: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
+
+export declare interface PaginationConfig {
+    /** Default page size */
+    pageSize?: number;
+    /** Available page size options */
+    pageSizeOptions?: number[];
+    /** Number of sibling pages to show */
+    siblingCount?: number;
+    /** Show first/last page numbers */
+    showEdges?: boolean;
+}
+
+export declare interface PaginationProps {
+    /** Current active page (v-model) */
+    modelValue: number;
+    /** Total count of items */
+    total: number;
+    /** Items per page */
+    pageSize?: number;
+    /** Number of pages to show on each side of current page */
+    siblingCount?: number;
+    /** Whether to always show first/last page numbers */
+    showEdges?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disable all controls */
+    disabled?: boolean;
+}
+
+export declare function parseColorString(color: string): {
+    hsv: HSV;
+    alpha: number;
+    format: 'hex' | 'rgb' | 'oklch';
+} | null;
+
+/**
+ * Parse an ISO 8601 date string (YYYY-MM-DD) to a Date object.
+ * Returns null for invalid input.
+ *
+ * @param dateString - ISO date string in YYYY-MM-DD format
+ * @returns Date object or null if invalid
+ *
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+export declare function parseDate(dateString: string): Date | null;
+
+/**
+ * Time parsing and formatting utilities for TimePicker component
+ */
+export declare interface ParsedTime {
+    hours: number;
+    minutes: number;
+}
+
+/**
+ * Parses fuzzy time input strings into structured time object.
+ * Supports formats: "1p", "1:30pm", "13:00", "100pm", "1 30 am", etc.
+ */
+export declare function parseTime(input: string): ParsedTime | null;
+
+export declare type Placement = 'top' | 'bottom' | 'left' | 'right';
+
+declare interface PointClickData {
+    datasetIndex: number;
+    index: number;
+    label: string;
+    value: number | string;
+    datasetLabel: string;
+}
+
+export declare const Popover: __VLS_WithTemplateSlots_37<typeof __VLS_component_35, __VLS_TemplateResult_35["slots"]>;
+
+export declare type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+
+export declare interface PopoverProps {
+    /** Popover placement relative to trigger */
+    placement?: PopoverPlacement;
+    /** Offset from trigger (px) */
+    offset?: number;
+    /** Show arrow pointing to trigger */
+    arrow?: boolean;
+    /** Disable the popover */
+    disabled?: boolean;
+    /** Width of the popover ('auto' or px value) */
+    width?: 'auto' | number;
+    /** Close on Escape key */
+    closeOnEscape?: boolean;
+    /** Close when clicking outside */
+    closeOnClickOutside?: boolean;
+    /** Lock body scroll when open */
+    lockScroll?: boolean;
+    /** Trap focus inside popover */
+    trapFocus?: boolean;
+}
+
+declare interface PositionResult {
+    top: number;
+    left: number;
+    actualPlacement: Placement;
+}
+
+export declare const Progress: DefineComponent<ProgressProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
+variant: ProgressVariant;
+size: ProgressSize;
+color: ProgressColor;
+value: number;
+indeterminate: boolean;
+striped: boolean;
+animated: boolean;
+showValue: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare type ProgressColor = 'primary' | 'success' | 'warning' | 'error';
+
+export declare interface ProgressProps {
+    /** Current progress value (0-100) */
+    value?: number;
+    /** Display variant */
+    variant?: ProgressVariant;
+    /** Size of the progress indicator */
+    size?: ProgressSize;
+    /** Color theme */
+    color?: ProgressColor;
+    /** Show indeterminate animation (unknown duration) */
+    indeterminate?: boolean;
+    /** Show diagonal stripes (linear only) */
+    striped?: boolean;
+    /** Animate stripes (linear only, requires striped) */
+    animated?: boolean;
+    /** Show percentage value label */
+    showValue?: boolean;
+    /** Accessible label describing the progress */
+    label?: string;
+    /** Stroke width for circular variant (default auto based on size) */
+    strokeWidth?: number;
+}
+
+export declare type ProgressSize = 'sm' | 'md' | 'lg';
+
+export declare type ProgressVariant = 'linear' | 'circular';
+
+export declare const Radio: DefineComponent<RadioProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number | boolean) => any;
+change: (value: string | number | boolean) => any;
+}, string, PublicProps, Readonly<RadioProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number | boolean) => any) | undefined;
+onChange?: ((value: string | number | boolean) => any) | undefined;
+}>, {
+size: "sm" | "md" | "lg";
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLabelElement>;
+
+export declare interface RadioProps {
+    /** Selected value (v-model) - shared across radio group */
+    modelValue?: string | number | boolean;
+    /** Value of this radio option */
+    value: string | number | boolean;
+    /** Radio size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Visible label text */
+    label?: string;
+    /** Description text below label */
+    description?: string;
+    /** HTML name for radio group (required for native behavior) */
+    name?: string;
+    /** ID for label association */
+    id?: string;
+}
+
+/**
+ * Computed range class for a date cell in range mode.
+ */
+export declare type RangeClass = 'start' | 'end' | 'in-range' | null;
+
+/**
+ * Range selection state for two-click selection.
+ */
+export declare type RangeState = 'idle' | 'selecting';
+
+export declare const Rating: DefineComponent<RatingProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: number) => any;
+hover: (value: number | null) => any;
+}, string, PublicProps, Readonly<RatingProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: number) => any) | undefined;
+onHover?: ((value: number | null) => any) | undefined;
+}>, {
+label: string;
+size: "sm" | "md" | "lg";
+max: number;
+readonly: boolean;
+allowHalf: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface RatingProps {
+    /** Current rating value (0 to max) */
+    modelValue: number;
+    /** Maximum rating value */
+    max?: number;
+    /** Read-only mode */
+    readonly?: boolean;
+    /** Enable half-star precision */
+    allowHalf?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Accessible label */
+    label?: string;
+}
+
+declare function replaceFile(file: UploadFile): void;
+
+/**
+ * Reset icons to defaults. Useful for testing.
+ */
+export declare function resetIcons(): void;
+
+export declare interface ResponsiveColumns {
+    default?: ColumnCount;
+    sm?: ColumnCount;
+    md?: ColumnCount;
+    lg?: ColumnCount;
+    xl?: ColumnCount;
+}
+
+export declare interface ResponsiveSpan {
+    default?: SpanCount;
+    sm?: SpanCount;
+    md?: SpanCount;
+    lg?: SpanCount;
+    xl?: SpanCount;
+}
+
+export declare interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+
+export declare interface RGBA extends RGB {
+    a: number;
+}
+
+export declare function rgbToHex(rgb: RGB): string;
+
+export declare function rgbToHsv(rgb: RGB): HSV;
+
+export declare function rgbToOklch(rgb: RGB): OKLCH;
+
+declare interface SafeTriangleState {
+    active: boolean;
+    points: {
+        x: number;
+        y: number;
+    }[];
+    submenuId: string | null;
+}
+
+declare interface SegmentClickData {
+    segment: DonutChartSegment;
+    index: number;
+    percentage: number;
+}
+
+export declare const SegmentedControl: DefineComponent<SegmentedControlProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number) => any;
+change: (value: string | number) => any;
+}, string, PublicProps, Readonly<SegmentedControlProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+onChange?: ((value: string | number) => any) | undefined;
+}>, {
+size: "sm" | "md" | "lg";
+disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+containerRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+export declare interface SegmentedControlProps {
+    /** Array of options to display */
+    options: SegmentedOption[];
+    /** Selected value (v-model) */
+    modelValue?: string | number;
+    /** Control size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Accessible label for the group */
+    label?: string;
+    /** HTML name for form submission */
+    name?: string;
+    /** ID for the control */
+    id?: string;
+}
+
+export declare interface SegmentedOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+
+export declare const Select: DefineComponent<SelectProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string | number | null) => any;
+change: (value: string | number | null) => any;
+}, string, PublicProps, Readonly<SelectProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string | number | null) => any) | undefined;
+onChange?: ((value: string | number | null) => any) | undefined;
+}>, {
+modelValue: string | number | null;
+size: "xs" | "sm" | "md" | "lg" | "xl";
+disabled: boolean;
+required: boolean;
+placeholder: string;
+block: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+triggerRef: HTMLButtonElement;
+listboxRef: HTMLUListElement;
+}, HTMLDivElement>;
+
+export declare interface SelectOption {
+    /** Display text shown to user */
+    label: string;
+    /** Value stored in v-model */
+    value: string | number;
+    /** Disable this option */
+    disabled?: boolean;
+}
+
+export declare interface SelectProps {
+    /** Selected value (v-model) */
+    modelValue?: string | number | null;
+    /** Available options */
+    options: SelectOption[];
+    /** Label text above select */
+    label?: string;
+    /** Placeholder when no selection */
+    placeholder?: string;
+    /** Helper text below select */
+    hint?: string;
+    /** Error message (also sets error state) */
+    error?: string;
+    /** Select size - matches Input heights */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Required field */
+    required?: boolean;
+    /** Make select full width */
+    block?: boolean;
+    /** HTML id attribute */
+    id?: string;
+    /** HTML name attribute (for forms) */
+    name?: string;
+}
+
+export declare interface SidebarContext {
+    collapsed: ComputedRef<boolean>;
+    expandedWidth: Ref<string>;
+    collapsedWidth: Ref<string>;
+}
+
+export declare const SidebarGroup: __VLS_WithTemplateSlots_41<typeof __VLS_component_39, __VLS_TemplateResult_39["slots"]>;
+
+export declare interface SidebarGroupContext {
+    groupId: string;
+}
+
+export declare const SidebarGroupKey: InjectionKey<SidebarGroupContext>;
+
+export declare interface SidebarGroupProps {
+    /** Group label displayed when expanded */
+    label?: string;
+    /** Show separator line when collapsed */
+    showSeparator?: boolean;
+}
+
+export declare const SidebarItem: __VLS_WithTemplateSlots_40<typeof __VLS_component_38, __VLS_TemplateResult_38["slots"]>;
+
+export declare interface SidebarItemProps {
+    /** Text label for the item */
+    label: string;
+    /** Icon component or HugeIcons data */
+    icon?: IconInput_2;
+    /** Whether this item is currently active */
+    active?: boolean;
+    /** Disable this item */
+    disabled?: boolean;
+    /** Render as a different element (button, a, RouterLink) */
+    as?: string | Component;
+    /** href for anchor elements */
+    href?: string;
+    /** Target for anchor elements */
+    target?: string;
+    /** Route object for router-link */
+    to?: string | Record<string, unknown>;
+}
+
+export declare const SidebarKey: InjectionKey<SidebarContext>;
+
+export declare const SidebarLayout: __VLS_WithTemplateSlots_38<typeof __VLS_component_36, __VLS_TemplateResult_36["slots"]>;
+
+export declare interface SidebarLayoutProps {
+    /** Position of the sidebar */
+    sidebarPosition?: 'left' | 'right';
+}
+
+export declare const SidebarRoot: __VLS_WithTemplateSlots_39<typeof __VLS_component_37, __VLS_TemplateResult_37["slots"]>;
+
+export declare interface SidebarRootProps {
+    /** Whether the sidebar is collapsed */
+    modelValue?: boolean;
+    /** Width when expanded */
+    expandedWidth?: string;
+    /** Width when collapsed */
+    collapsedWidth?: string;
+}
+
+export declare const Skeleton: DefineComponent<SkeletonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {
+variant: SkeletonVariant;
+animation: "shimmer" | "pulse" | "none";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLSpanElement>;
+
+export declare interface SkeletonProps {
+    /** Shape variant */
+    variant?: SkeletonVariant;
+    /** Width (px, %, or CSS value) */
+    width?: string | number;
+    /** Height (px or CSS value) */
+    height?: string | number;
+    /** Animation style */
+    animation?: 'shimmer' | 'pulse' | 'none';
+}
+
+export declare type SkeletonVariant = 'text' | 'circle' | 'rect';
+
+export declare const Slider: DefineComponent<SliderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: number | [number, number]) => any;
+change: (value: number | [number, number]) => any;
+}, string, PublicProps, Readonly<SliderProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: number | [number, number]) => any) | undefined;
+onChange?: ((value: number | [number, number]) => any) | undefined;
+}>, {
+size: "sm" | "md" | "lg";
+disabled: boolean;
+max: number;
+step: number;
+min: number;
+showTooltip: boolean;
+showTicks: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+trackRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+export declare interface SliderProps {
+    /** Current value (number for single, [min, max] tuple for range) */
+    modelValue: number | [number, number];
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Show tooltip while dragging */
+    showTooltip?: boolean;
+    /** Show tick marks at each step */
+    showTicks?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+}
+
+export declare type SortDirection = 'asc' | 'desc' | null;
+
+export declare interface SortState {
+    key: string | null;
+    direction: SortDirection;
+}
+
+export declare type SpacingToken = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12;
+
+export declare type SpanCount = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'full';
+
+export declare const Spinner: DefineComponent<SpinnerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SpinnerProps> & Readonly<{}>, {
+label: string;
+size: "xs" | "sm" | "md" | "lg" | "xl" | string;
+speed: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface SpinnerProps {
+    /** Predefined size or custom value */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | string;
+    /** Animation speed in seconds */
+    speed?: number;
+    /** Accessible label for screen readers */
+    label?: string;
+}
+
+export declare interface SpireConfig {
+    theme?: Theme;
+    mood?: Mood;
+    depth?: Depth;
+    motion?: Motion;
+    texture?: Texture;
+}
+
+export declare const spireConfigKey: InjectionKey<ComputedRef<SpireConfig>>;
+
+export declare const SpireProvider: __VLS_WithTemplateSlots_42<DefineComponent<SpireProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SpireProviderProps> & Readonly<{}>, {
+tag: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+
+export declare interface SpireProviderProps {
+    theme?: Theme;
+    mood?: Mood;
+    depth?: Depth;
+    motion?: Motion;
+    texture?: Texture;
+    tag?: string;
+}
+
+export declare const Stack: __VLS_WithTemplateSlots_58<typeof __VLS_component_55, __VLS_TemplateResult_55["slots"]>;
+
+export declare interface StackProps {
+    /** Flex direction */
+    direction?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    /** Gap using spacing tokens (maps to var(--space-X)) */
+    gap?: SpacingToken;
+    /** Align items */
+    align?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+    /** Justify content */
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+    /** Enable flex wrap */
+    wrap?: boolean;
+    /** Use inline-flex instead of flex */
+    inline?: boolean;
+    /** HTML tag to render */
+    as?: string;
+}
+
+export declare const StepperContent: __VLS_WithTemplateSlots_46<typeof __VLS_component_43, __VLS_TemplateResult_43["slots"]>;
+
+export declare interface StepperContext {
+    orientation: Ref<StepperOrientation>;
+    linear: Ref<boolean>;
+    currentStep: Ref<number>;
+    goToStep: (step: number) => void;
+    getStepState: (index: number) => StepState;
+    canNavigateTo: (index: number) => boolean;
+    registerStep: (index: number) => void;
+    stepCount: Ref<number>;
+}
+
+export declare const StepperItem: __VLS_WithTemplateSlots_44<typeof __VLS_component_41, __VLS_TemplateResult_41["slots"]>;
+
+export declare interface StepperItemContext {
+    index: number;
+    state: ComputedRef<StepState>;
+    isDisabled: ComputedRef<boolean>;
+    triggerId: string;
+    contentId: string;
+    goToStep: () => void;
+}
+
+export declare const StepperItemKey: InjectionKey<StepperItemContext>;
+
+export declare interface StepperItemProps {
+    /** Step index (0-based) */
+    index: number;
+    /** Disable this step */
+    disabled?: boolean;
+}
+
+export declare const StepperKey: InjectionKey<StepperContext>;
+
+export declare type StepperOrientation = 'horizontal' | 'vertical';
+
+export declare const StepperRoot: __VLS_WithTemplateSlots_43<typeof __VLS_component_40, __VLS_TemplateResult_40["slots"]>;
+
+export declare interface StepperRootProps {
+    /** Current step index (0-based, v-model) */
+    modelValue?: number;
+    /** Layout direction */
+    orientation?: StepperOrientation;
+    /** Prevents clicking future steps */
+    linear?: boolean;
+    /** Mark specific steps as having errors */
+    errorSteps?: number[];
+}
+
+export declare const StepperSeparator: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+export declare const StepperTrigger: __VLS_WithTemplateSlots_45<typeof __VLS_component_42, __VLS_TemplateResult_42["slots"]>;
+
+export declare interface StepperTriggerProps {
+    /** Custom icon to display instead of step number */
+    icon?: Component;
+}
+
+export declare type StepState = 'completed' | 'current' | 'pending' | 'error';
+
+declare interface SubmenuRegistration {
+    id: string;
+    triggerEl: HTMLElement;
+    open: () => void;
+    close: () => void;
+}
+
+export declare const Switch: DefineComponent<SwitchProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: boolean) => any;
+change: (value: boolean) => any;
+}, string, PublicProps, Readonly<SwitchProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+onChange?: ((value: boolean) => any) | undefined;
+}>, {
+modelValue: boolean;
+size: "sm" | "md" | "lg";
+disabled: boolean;
+loading: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
+
+export declare interface SwitchProps {
+    /** Checked state (v-model) */
+    modelValue?: boolean;
+    /** Switch size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Loading state - shows spinner in thumb */
+    loading?: boolean;
+    /** Accessible label (required for a11y if no visible label) */
+    label?: string;
+    /** HTML name for form submission */
+    name?: string;
+    /** ID for label association */
+    id?: string;
+}
+
+export declare interface TabItem {
+    /** Display label */
+    label: string;
+    /** Unique value (used for v-model and slot name) */
+    value: string | number;
+    /** Disable this tab */
+    disabled?: boolean;
+    /** Optional icon */
+    icon?: IconInput;
+}
+
+export declare const Tabs: __VLS_WithTemplateSlots_47<typeof __VLS_component_44, __VLS_TemplateResult_44["slots"]>;
+
+export declare interface TabsProps {
+    /** Currently active tab value (v-model) */
+    modelValue: string | number;
+    /** Tab items configuration */
+    items: TabItem[];
+    /** Visual variant */
+    variant?: 'line' | 'pill';
+    /** Full width tabs */
+    block?: boolean;
+}
+
+declare const Text_2: __VLS_WithTemplateSlots_49<typeof __VLS_component_46, __VLS_TemplateResult_46["slots"]>;
+export { Text_2 as Text }
+
+export declare const Textarea: __VLS_WithTemplateSlots_48<typeof __VLS_component_45, __VLS_TemplateResult_45["slots"]>;
+
+export declare interface TextareaProps {
+    /** Textarea value (v-model) */
+    modelValue?: string;
+    /** Label text above the textarea */
+    label?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Helper text below textarea */
+    hint?: string;
+    /** Error message (also sets error state) */
+    error?: string;
+    /** Number of visible rows */
+    rows?: number;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Read-only state */
+    readonly?: boolean;
+    /** Required field */
+    required?: boolean;
+    /** Auto-grow as user types */
+    autosize?: boolean;
+    /** Maximum height in pixels (for autosize) */
+    maxHeight?: number;
+    /** Maximum character count */
+    maxLength?: number;
+    /** Show character counter */
+    showCount?: boolean;
+    /** Icon on the left side (top-aligned) */
+    iconLeft?: IconInput;
+    /** HTML id attribute (auto-generated if not provided) */
+    id?: string;
+    /** HTML name attribute */
+    name?: string;
+    /** Make textarea full width */
+    block?: boolean;
+}
+
+export declare interface TextProps {
+    /** Semantic HTML tag */
+    as?: TextTag;
+    /** Font size */
+    size?: TextSize;
+    /** Font weight */
+    weight?: TextWeight;
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right' | 'justify';
+    /** Use secondary (muted) color */
+    muted?: boolean;
+    /** Single-line truncation with ellipsis */
+    truncate?: boolean;
+    /** Multi-line clamping (number of lines) */
+    clamp?: number;
+}
+
+declare type TextSize = 'xs' | 'sm' | 'base' | 'md' | 'lg' | 'xl';
+
+declare type TextTag = 'p' | 'span' | 'div' | 'label' | 'li';
+
+export declare type Texture = 'none' | 'subtle' | 'medium';
+
+declare type TextWeight = 'regular' | 'medium' | 'semibold' | 'bold';
+
+export declare type Theme = 'light' | 'dark';
+
+export declare type TimeFormat = '12h' | '24h';
+
+export declare const Timeline: __VLS_WithTemplateSlots_50<typeof __VLS_component_47, __VLS_TemplateResult_47["slots"]>;
+
+export declare type TimelineAlign = 'left' | 'right' | 'alternate';
+
+export declare interface TimelineContext {
+    align: Ref<TimelineAlign>;
+    lineStyle: Ref<TimelineLineStyle>;
+    registerItem: () => number;
+    itemCount: Ref<number>;
+}
+
+export declare type TimelineDotColor = 'primary' | 'success' | 'warning' | 'danger' | 'neutral';
+
+export declare const TimelineItem: __VLS_WithTemplateSlots_51<typeof __VLS_component_48, __VLS_TemplateResult_48["slots"]>;
+
+export declare interface TimelineItemProps {
+    /** Dot color variant */
+    dotColor?: TimelineDotColor;
+    /** Custom icon in dot */
+    dotIcon?: Component;
+}
+
+export declare const TimelineKey: InjectionKey<TimelineContext>;
+
+export declare type TimelineLineStyle = 'solid' | 'dashed' | 'dotted';
+
+export declare interface TimelineProps {
+    /** Content alignment relative to the spine */
+    align?: TimelineAlign;
+    /** Connector line style */
+    lineStyle?: TimelineLineStyle;
+}
+
+export declare const TimePicker: DefineComponent<TimePickerProps, {
+open: () => void | undefined;
+close: () => void | undefined;
+toggle: () => void | undefined;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: string) => any;
+blur: (event: FocusEvent) => any;
+focus: (event: FocusEvent) => any;
+}, string, PublicProps, Readonly<TimePickerProps> & Readonly<{
+"onUpdate:modelValue"?: ((value: string) => any) | undefined;
+onBlur?: ((event: FocusEvent) => any) | undefined;
+onFocus?: ((event: FocusEvent) => any) | undefined;
+}>, {
+size: "xs" | "sm" | "md" | "lg" | "xl";
+disabled: boolean;
+required: boolean;
+block: boolean;
+format: TimeFormat;
+minuteStep: number;
+closeOnSelect: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+popoverRef: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly placement?: PopoverPlacement | undefined;
+readonly offset?: number | undefined;
+readonly arrow?: boolean | undefined;
+readonly disabled?: boolean | undefined;
+readonly width?: "auto" | number | undefined;
+readonly closeOnEscape?: boolean | undefined;
+readonly closeOnClickOutside?: boolean | undefined;
+readonly lockScroll?: boolean | undefined;
+readonly trapFocus?: boolean | undefined;
+readonly onClose?: (() => any) | undefined;
+readonly onOpen?: (() => any) | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+} & {
+triggerRef: HTMLDivElement;
+popoverRef: HTMLDivElement;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: ((event: "close") => void) & ((event: "open") => void);
+$el: HTMLDivElement;
+$options: ComponentOptionsBase<Readonly<PopoverProps> & Readonly<{
+onClose?: (() => any) | undefined;
+onOpen?: (() => any) | undefined;
+}>, {
+open: () => void;
+close: () => void;
+toggle: () => void;
+isOpen: Ref<boolean, boolean>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+close: () => any;
+open: () => any;
+}, string, {
+disabled: boolean;
+width: "auto" | number;
+placement: PopoverPlacement;
+offset: number;
+arrow: boolean;
+closeOnEscape: boolean;
+closeOnClickOutside: boolean;
+lockScroll: boolean;
+trapFocus: boolean;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{
+disabled: boolean;
+width: "auto" | number;
+placement: PopoverPlacement;
+offset: number;
+arrow: boolean;
+closeOnEscape: boolean;
+closeOnClickOutside: boolean;
+lockScroll: boolean;
+trapFocus: boolean;
+}> & Omit<Readonly<PopoverProps> & Readonly<{
+onClose?: (() => any) | undefined;
+onOpen?: (() => any) | undefined;
+}>, "close" | "toggle" | "isOpen" | "open" | ("disabled" | "width" | "placement" | "offset" | "arrow" | "closeOnEscape" | "closeOnClickOutside" | "lockScroll" | "trapFocus")> & ShallowUnwrapRef<    {
+open: () => void;
+close: () => void;
+toggle: () => void;
+isOpen: Ref<boolean, boolean>;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+trigger?(_: {
+open: boolean;
+toggle: () => void;
+close: () => void;
+}): any;
+default?(_: {
+close: () => void;
+}): any;
+};
+}) | null;
+hourColumnRef: HTMLDivElement;
+minuteColumnRef: HTMLDivElement;
+periodColumnRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+export declare interface TimePickerProps {
+    /** Selected time in HH:mm format (24h) */
+    modelValue?: string;
+    /** Time display format */
+    format?: TimeFormat;
+    /** Minute step interval */
+    minuteStep?: number;
+    /** Label text above the input */
+    label?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Helper text below input */
+    hint?: string;
+    /** Error message (also sets error state) */
+    error?: string;
+    /** Input size */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Required field */
+    required?: boolean;
+    /** HTML id attribute */
+    id?: string;
+    /** HTML name attribute */
+    name?: string;
+    /** Make input full width */
+    block?: boolean;
+    /** Close popover when time is selected */
+    closeOnSelect?: boolean;
+}
+
+/**
+ * Converts 24h hours to 12h format
+ */
+export declare function to12Hour(hours: number): {
+    hour: number;
+    period: 'AM' | 'PM';
+};
+
+/**
+ * Converts 12h format to 24h hours
+ */
+export declare function to24Hour(hour: number, period: 'AM' | 'PM'): number;
+
+export declare interface Toast {
+    /** Unique identifier */
+    id: string;
+    /** Toast title */
+    title?: string;
+    /** Toast message/description */
+    message?: string;
+    /** Visual variant */
+    variant: ToastVariant;
+    /** Auto-dismiss duration in ms */
+    duration: number;
+    /** Timestamp when created */
+    createdAt: number;
+    /** Single action button */
+    action?: ToastAction;
+    /** Click handler for toast body */
+    onClick?: () => void;
+    /** Avatar props for notification toasts */
+    avatar?: {
+        src?: string;
+        name?: string;
+    };
+}
+
+export declare interface ToastAction {
+    /** Action button label (keep short: Undo, Retry, View) */
+    label: string;
+    /** Callback when action is clicked */
+    onClick: () => void;
+}
+
+export declare const ToastItem: DefineComponent<ToastItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+dismiss: (id: string) => any;
+}, string, PublicProps, Readonly<ToastItemProps> & Readonly<{
+onDismiss?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare interface ToastItemProps {
+    /** Toast data */
+    toast: Toast;
+}
+
+export declare interface ToastOptions {
+    /** Toast title */
+    title?: string;
+    /** Toast message/description */
+    message?: string;
+    /** Visual variant */
+    variant?: ToastVariant;
+    /** Auto-dismiss duration in ms (0 = no auto-dismiss). Defaults to 8000ms if action provided, 5000ms otherwise */
+    duration?: number;
+    /** Single action button (Undo, Retry, View) */
+    action?: ToastAction;
+    /** Click handler for toast body (for navigation) */
+    onClick?: () => void;
+    /** Avatar component props for notification-style toasts (replaces icon) */
+    avatar?: {
+        src?: string;
+        name?: string;
+    };
+}
+
+export declare const ToastProvider: DefineComponent<ToastProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToastProviderProps> & Readonly<{}>, {
+position: "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface ToastProviderProps {
+    /** Position of the toast container */
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
+}
+
+export declare type ToastVariant = 'success' | 'error' | 'warning' | 'info';
+
+declare function toggle(): void;
+
+declare function toggle_2(): void;
+
+export declare const ToggleButton: __VLS_WithTemplateSlots_52<typeof __VLS_component_49, __VLS_TemplateResult_49["slots"]>;
+
+export declare interface ToggleButtonProps {
+    /** Pressed state for standalone usage (v-model) */
+    modelValue?: boolean;
+    /** Value for group usage */
+    value?: string | number;
+    /** Button size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state */
+    disabled?: boolean;
+    /** Icon to display */
+    icon?: IconInput;
+    /** Accessible label (required when icon-only) */
+    label?: string;
+}
+
+declare function toggleDataset(index: number): void;
+
+export declare const ToggleGroup: __VLS_WithTemplateSlots_53<typeof __VLS_component_50, __VLS_TemplateResult_50["slots"]>;
+
+export declare interface ToggleGroupProps {
+    /** Selected value(s) - single value for 'single' type, array for 'multiple' */
+    modelValue?: string | number | (string | number)[];
+    /** Selection type */
+    type?: 'single' | 'multiple';
+    /** Size for all buttons in group */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disabled state for all buttons */
+    disabled?: boolean;
+    /** Accessible label for the group */
+    label?: string;
+    /** Orientation for keyboard navigation */
+    orientation?: 'horizontal' | 'vertical';
+}
+
+export declare const Tooltip: __VLS_WithTemplateSlots_54<typeof __VLS_component_51, __VLS_TemplateResult_51["slots"]>;
+
+export declare interface TooltipData {
+    title: string;
+    items: Array<{
+        label: string;
+        value: string;
+        color: string;
+    }>;
+    x: number;
+    y: number;
+}
+
+export declare interface TooltipProps {
+    /** Tooltip text content */
+    text: string;
+    /** Preferred placement (may flip on collision) */
+    placement?: Placement;
+    /** Delay before showing (ms) - prevents flicker on rapid mouseover */
+    delay?: number;
+    /** Gap between trigger and tooltip */
+    offset?: number;
+    /** Disable the tooltip */
+    disabled?: boolean;
+}
+
+export declare interface TreeNode {
+    id: string;
+    label: string;
+    icon?: Component;
+    children?: TreeNode[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+}
+
+export declare const TreeView: __VLS_WithTemplateSlots_55<typeof __VLS_component_52, __VLS_TemplateResult_52["slots"]>;
+
+export declare interface TreeViewContext {
+    selectedIds: Ref<Set<string>>;
+    expandedIds: Ref<Set<string>>;
+    focusedId: Ref<string | null>;
+    multiSelect: Ref<boolean>;
+    selectNode: (id: string) => void;
+    toggleExpand: (id: string) => void;
+    setFocusedId: (id: string | null) => void;
+    loadChildren: ((node: TreeNode) => Promise<TreeNode[]>) | null;
+    loadingIds: Ref<Set<string>>;
+    registerNode: (id: string, parentId: string | null, hasChildren: boolean) => void;
+    getVisibleNodes: () => string[];
+    getParentId: (id: string) => string | null;
+    getChildIds: (id: string) => string[];
+    hasChildren: (id: string) => boolean;
+}
+
+export declare const TreeViewItem: __VLS_WithTemplateSlots_56<typeof __VLS_component_53, __VLS_TemplateResult_53["slots"]>;
+
+export declare interface TreeViewItemContext {
+    depth: number;
+    parentId: string | null;
+}
+
+export declare const TreeViewItemKey: InjectionKey<TreeViewItemContext>;
+
+export declare interface TreeViewItemProps {
+    /** Node data */
+    node: TreeNode;
+}
+
+export declare const TreeViewKey: InjectionKey<TreeViewContext>;
+
+export declare interface TreeViewProps {
+    /** Hierarchical data */
+    data: TreeNode[];
+    /** Selected node ID(s) - v-model */
+    modelValue?: string | string[];
+    /** Expanded node IDs - v-model:expandedIds */
+    expandedIds?: string[];
+    /** Enable multi-selection */
+    multiSelect?: boolean;
+    /** Lazy load callback */
+    loadChildren?: (node: TreeNode) => Promise<TreeNode[]>;
+}
+
+declare function triggerInput(): void;
+
+/**
+ * Update file progress (call from parent during upload)
+ */
+declare function updateProgress(fileId: string, progress: number): void;
+
+export declare interface UploadFile {
+    /** Unique identifier */
+    id: string;
+    /** Original File object */
+    file: File;
+    /** File name */
+    name: string;
+    /** File size in bytes */
+    size: number;
+    /** MIME type */
+    type: string;
+    /** Preview URL (for images) */
+    preview?: string;
+    /** Upload progress (0-100) */
+    progress: number;
+    /** Upload status */
+    status: 'pending' | 'uploading' | 'success' | 'error';
+    /** Error message if status is error */
+    error?: string;
+}
+
+/**
+ * Composable that extracts CSS variables and provides reactive chart theming.
+ * Automatically updates when the theme changes (dark mode toggle).
+ */
+export declare function useChartTheme(): {
+    theme: Ref<    {
+    colors: {
+    primary: string;
+    success: string;
+    warning: string;
+    error: string;
+    info: string;
+    text: string;
+    textMuted: string;
+    gridLines: string;
+    tooltipBg: string;
+    tooltipText: string;
+    tooltipBorder: string;
+    legendText: string;
+    };
+    fontFamily: string;
+    palette: string[];
+    }, ChartTheme | {
+    colors: {
+    primary: string;
+    success: string;
+    warning: string;
+    error: string;
+    info: string;
+    text: string;
+    textMuted: string;
+    gridLines: string;
+    tooltipBg: string;
+    tooltipText: string;
+    tooltipBorder: string;
+    legendText: string;
+    };
+    fontFamily: string;
+    palette: string[];
+    }>;
+    themeVersion: Ref<number, number>;
+    gridColor: ComputedRef<string>;
+    textColor: ComputedRef<string>;
+    mutedTextColor: ComputedRef<string>;
+    getDefaultOptions: () => {
+        responsive: boolean;
+        maintainAspectRatio: boolean;
+        plugins: {
+            legend: {
+                display: boolean;
+            };
+            tooltip: {
+                enabled: boolean;
+            };
+        };
+        scales: {
+            x: {
+                grid: {
+                    display: boolean;
+                };
+                border: {
+                    display: boolean;
+                };
+                ticks: {
+                    color: string;
+                    font: {
+                        family: string;
+                        size: number;
+                    };
+                };
+            };
+            y: {
+                grid: {
+                    color: string;
+                };
+                border: {
+                    display: boolean;
+                };
+                ticks: {
+                    color: string;
+                    font: {
+                        family: string;
+                        size: number;
+                    };
+                };
+            };
+        };
+    };
+    getColor: (index: number) => string;
+    getColorWithOpacity: (index: number, opacity: number) => string;
+    updateTheme: () => void;
+};
+
+/**
+ * Detects clicks outside of a target element and executes a callback.
+ * Essential for modals, dropdowns, and popovers.
+ *
+ * @param el - Ref to the element to watch
+ * @param handler - Callback executed when click occurs outside
+ *
+ * Time Complexity: O(1) per event
+ * Space Complexity: O(1)
+ */
+export declare function useClickOutside(el: Ref<HTMLElement | null>, handler: () => void): void;
+
+/**
+ * Copy text to clipboard with success state tracking.
+ * @param timeout Reset duration for copied state (ms)
+ */
+export declare function useClipboard(timeout?: number): {
+    copy: (text: string) => Promise<boolean>;
+    copied: Ref<boolean, boolean>;
+};
+
+/**
+ * Attaches an event listener with automatic cleanup on unmount.
+ * Prevents memory leaks from forgotten removeEventListener calls.
+ */
+export declare function useEventListener<K extends keyof WindowEventMap>(target: MaybeRef<EventTarget_2>, event: K, callback: (e: WindowEventMap[K]) => void, options?: AddEventListenerOptions): void;
+
+export declare function useEventListener(target: MaybeRef<EventTarget_2>, event: string, callback: (e: Event) => void, options?: AddEventListenerOptions): void;
+
+/**
+ * Traps focus within a container element when active.
+ * Tab cycles through focusable elements, never escaping the container.
+ * Critical for modal accessibility.
+ */
+export declare function useFocusTrap(container: Ref<HTMLElement | null>, isActive: Ref<boolean>): void;
+
+/**
+ * Creates a radial gradient spotlight effect that follows the cursor on hover.
+ * Handles deferred elements (tabs, v-if) by watching for target availability.
+ *
+ * @param target - Ref to the target element
+ * @param options - Configuration options
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const cardRef = ref<HTMLElement | null>(null)
+ * useHoverReveal(cardRef, { size: 200, opacity: 0.1 })
+ * </script>
+ *
+ * <template>
+ *   <div ref="cardRef" data-hover-reveal>Hover over me</div>
+ * </template>
+ * ```
+ */
+export declare function useHoverReveal(target: Ref<HTMLElement | null>, options?: UseHoverRevealOptions): void;
+
+export declare interface UseHoverRevealOptions {
+    size?: number;
+    opacity?: number;
+}
+
+/**
+ * Generates a unique ID for accessibility attributes.
+ * Links labels to inputs, aria-labelledby to modals, etc.
+ * @param prefix Optional prefix (default: 'ui')
+ */
+export declare function useId(prefix?: string): string;
+
+/**
+ * Creates a magnetic hover effect where the element subtly follows the cursor.
+ * Handles deferred elements (tabs, v-if) by watching for target availability.
+ *
+ * @param target - Ref to the target element
+ * @param options - Configuration options
+ * @returns Reactive values for position and style
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const buttonRef = ref<HTMLElement | null>(null)
+ * const { style } = useMagnetic(buttonRef, { strength: 0.3 })
+ * </script>
+ *
+ * <template>
+ *   <button ref="buttonRef" :style="style">Magnetic Button</button>
+ * </template>
+ * ```
+ */
+export declare function useMagnetic(target: Ref<HTMLElement | null>, options?: UseMagneticOptions): UseMagneticReturn;
+
+export declare interface UseMagneticOptions {
+    strength?: number;
+    radius?: number;
+    ease?: number;
+}
+
+export declare interface UseMagneticReturn {
+    x: Ref<number>;
+    y: Ref<number>;
+    isHovering: Ref<boolean>;
+    style: Ref<Record<string, string>>;
+}
+
+/**
+ * Composable for positioning floating elements relative to a trigger.
+ * Includes collision detection to flip placement when near viewport edges.
+ */
+export declare function useRelativePosition(trigger: Ref<HTMLElement | null>, content: Ref<HTMLElement | null>, placement?: Ref<Placement> | Placement | (() => Placement), offset?: number): {
+    coords: Ref<{
+        top: number;
+        left: number;
+        actualPlacement: Placement;
+    }, PositionResult | {
+        top: number;
+        left: number;
+        actualPlacement: Placement;
+    }>;
+    updatePosition: () => void;
+    getPlacement: () => Placement;
+};
+
+/**
+ * Creates a ripple effect on click for interactive elements.
+ * Handles deferred elements (tabs, v-if) by watching for target availability.
+ *
+ * @param target - Ref to the target element
+ * @param options - Configuration options
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const buttonRef = ref<HTMLElement | null>(null)
+ * useRipple(buttonRef, { color: 'white', opacity: 0.3 })
+ * </script>
+ *
+ * <template>
+ *   <button ref="buttonRef" data-ripple>Click me</button>
+ * </template>
+ * ```
+ */
+export declare function useRipple(target: Ref<HTMLElement | null>, options?: UseRippleOptions): void;
+
+export declare interface UseRippleOptions {
+    color?: string;
+    opacity?: number;
+    duration?: number;
+    disabled?: Ref<boolean> | boolean;
+}
+
+/**
+ * Locks body scroll when active, preventing background scrolling.
+ * Compensates for scrollbar width to prevent layout shift.
+ */
+export declare function useScrollLock(isLocked: Ref<boolean>): void;
+
+/**
+ * Creates sequential stagger animations for list items.
+ * Handles deferred elements (tabs, v-if) by watching for container availability.
+ *
+ * @param container - Ref to the container element
+ * @param itemSelector - CSS selector for items to animate
+ * @param options - Animation configuration
+ * @returns Controls for the stagger animation
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const listRef = ref<HTMLElement | null>(null)
+ * const { animate } = useStagger(listRef, '.list-item', {
+ *   delay: 80,
+ *   from: { opacity: 0, transform: 'translateY(12px)' },
+ *   to: { opacity: 1, transform: 'translateY(0)' }
+ * })
+ *
+ * // Trigger manually when ready
+ * function onTabVisible() {
+ *   animate()
+ * }
+ * </script>
+ *
+ * <template>
+ *   <ul ref="listRef">
+ *     <li class="list-item" v-for="item in items" :key="item.id">{{ item.name }}</li>
+ *   </ul>
+ * </template>
+ * ```
+ */
+export declare function useStagger(container: Ref<HTMLElement | null>, itemSelector: string, options?: UseStaggerOptions): UseStaggerReturn;
+
+export declare interface UseStaggerOptions {
+    delay?: number;
+    duration?: number;
+    easing?: string;
+    from?: {
+        opacity?: number;
+        transform?: string;
+    };
+    to?: {
+        opacity?: number;
+        transform?: string;
+    };
+    animateOnVisible?: boolean;
+}
+
+export declare interface UseStaggerReturn {
+    isAnimating: Ref<boolean>;
+    animate: () => Promise<void>;
+    reset: () => void;
+}
+
+/**
+ * Composable for triggering toast notifications.
+ * Can be used anywhere - components, stores, API interceptors.
+ *
+ * @example
+ * ```ts
+ * const toast = useToast()
+ *
+ * // Simple usage
+ * toast.success('Saved!')
+ * toast.error('Something went wrong')
+ *
+ * // With message
+ * toast.success('Profile updated', { message: 'Your changes have been saved.' })
+ *
+ * // Custom duration (ms)
+ * toast.info('Heads up', { duration: 10000 })
+ *
+ * // No auto-dismiss
+ * toast.warning('Action required', { duration: 0 })
+ *
+ * // Manual dismiss
+ * const id = toast.info('Processing...')
+ * // later...
+ * toast.dismiss(id)
+ * ```
+ */
+export declare function useToast(): {
+    /**
+     * Show a success toast
+     * @param title - Toast title
+     * @param options - Additional options (message, duration)
+     * @returns Toast ID for manual dismissal
+     */
+    success: (title: string, options?: Omit<ToastOptions, "title" | "variant">) => string;
+    /**
+     * Show an error toast
+     * @param title - Toast title
+     * @param options - Additional options (message, duration)
+     * @returns Toast ID for manual dismissal
+     */
+    error: (title: string, options?: Omit<ToastOptions, "title" | "variant">) => string;
+    /**
+     * Show a warning toast
+     * @param title - Toast title
+     * @param options - Additional options (message, duration)
+     * @returns Toast ID for manual dismissal
+     */
+    warning: (title: string, options?: Omit<ToastOptions, "title" | "variant">) => string;
+    /**
+     * Show an info toast
+     * @param title - Toast title
+     * @param options - Additional options (message, duration)
+     * @returns Toast ID for manual dismissal
+     */
+    info: (title: string, options?: Omit<ToastOptions, "title" | "variant">) => string;
+    /**
+     * Dismiss a specific toast
+     * @param id - Toast ID returned from success/error/warning/info
+     */
+    dismiss: (id: string) => void;
+    /**
+     * Dismiss all toasts
+     */
+    clear: () => void;
+};
+
+export { }