@sabrenski/spire-ui-vue 0.1.0 → 0.2.0

package/README.md

@@ -5,11 +5,11 @@ A modern, themeable Vue 3 component library with 57+ components, built with Type
 ## Installation
 
 ```bash
-npm install spire-ui
+npm install @sabrenski/spire-ui-vue
 # or
-pnpm add spire-ui
+pnpm add @sabrenski/spire-ui-vue
 # or
-yarn add spire-ui
+yarn add @sabrenski/spire-ui-vue
 ```
 
 ### Peer Dependencies
@@ -23,9 +23,9 @@ npm install vue@^3.0.0
 ```ts
 // main.ts
 import { createApp } from 'vue'
-import { SpireUI } from 'spire-ui'
+import { SpireUI } from '@sabrenski/spire-ui-vue'
 import App from './App.vue'
-import 'spire-ui/style.css'
+import '@sabrenski/spire-ui-vue/style.css'
 
 const app = createApp(App)
 
@@ -42,8 +42,8 @@ app.mount('#app')
 
 ```vue
 <script setup lang="ts">
-import { Button, Badge, Input, Card } from 'spire-ui'
-import type { ButtonProps } from 'spire-ui'
+import { Button, Badge, Input, Card } from '@sabrenski/spire-ui-vue'
+import type { ButtonProps } from '@sabrenski/spire-ui-vue'
 </script>
 
 <template>
@@ -62,8 +62,8 @@ Spire UI supports global default configuration for components using the Vue plug
 
 ```ts
 import { createApp } from 'vue'
-import { SpireUI } from 'spire-ui'
-import type { SpireUIOptions } from 'spire-ui'
+import { SpireUI } from '@sabrenski/spire-ui-vue'
+import type { SpireUIOptions } from '@sabrenski/spire-ui-vue'
 
 const app = createApp(App)
 
@@ -155,7 +155,7 @@ Props are resolved in the following order:
 You can also configure defaults programmatically:
 
 ```ts
-import { configureDefaults, getDefaults, resetDefaults } from 'spire-ui'
+import { configureDefaults, getDefaults, resetDefaults } from '@sabrenski/spire-ui-vue'
 
 // Set defaults at runtime
 configureDefaults({
@@ -247,7 +247,7 @@ resetDefaults()
 ## Composables
 
 ```ts
-import { useToast, useRovingFocus, useVirtualScroll, useComponentDefault } from 'spire-ui'
+import { useToast, useRovingFocus, useVirtualScroll, useComponentDefault } from '@sabrenski/spire-ui-vue'
 ```
 
 - **useToast** - Toast notification management
@@ -300,7 +300,7 @@ import { useToast, useRovingFocus, useVirtualScroll, useComponentDefault } from
 
 ```vue
 <script setup>
-import { Icon } from 'spire-ui'
+import { Icon } from '@sabrenski/spire-ui-vue'
 </script>
 
 <template>
@@ -318,7 +318,7 @@ import { Icon } from 'spire-ui'
 
 ```vue
 <script setup>
-import { useToast, ToastContainer } from 'spire-ui'
+import { useToast, ToastContainer } from '@sabrenski/spire-ui-vue'
 
 const toast = useToast()
 
@@ -378,7 +378,7 @@ import type {
   // Global configuration types
   SpireUIOptions,
   SpireUIDefaults,
-} from 'spire-ui'
+} from '@sabrenski/spire-ui-vue'
 ```
 
 ## Browser Support

package/dist/components/DialMenu/DialAction.vue.d.ts

@@ -0,0 +1,25 @@
+import { DialActionProps, DialColor } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DialActionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<DialActionProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    color: DialColor;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DialMenu/DialMenu.vue.d.ts

@@ -0,0 +1,45 @@
+import { DialMenuProps, DialPlacement } from './types';
+declare function toggle(): void;
+declare function open(): void;
+declare function close(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        trigger?(_: {
+            toggle: typeof toggle;
+            isOpen: boolean;
+            open: typeof open;
+            close: typeof close;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DialMenuProps, {
+    open: typeof open;
+    close: typeof close;
+    toggle: typeof toggle;
+    isOpen: import('vue').Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<DialMenuProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    disabled: boolean;
+    pattern: import('./types').DialPattern;
+    placement: DialPlacement;
+    trigger: import('./types').DialTriggerMode;
+    gap: number;
+    direction: import('./types').DialDirection;
+    arcSpread: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DialMenu/DialTrigger.vue.d.ts

@@ -0,0 +1,25 @@
+import { DialTriggerProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DialTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<DialTriggerProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    open: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DialMenu/index.d.ts

@@ -0,0 +1,4 @@
+export { default as DialMenu } from './DialMenu.vue';
+export { default as DialAction } from './DialAction.vue';
+export { default as DialTrigger } from './DialTrigger.vue';
+export * from './types';

package/dist/components/DialMenu/types.d.ts

@@ -0,0 +1,63 @@
+import { InjectionKey, Ref } from 'vue';
+export type DialPattern = 'linear' | 'arc';
+export type DialDirection = 'up' | 'down' | 'left' | 'right' | 'up-left' | 'up-right' | 'down-left' | 'down-right';
+export type DialPlacement = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+export type DialTriggerMode = 'click' | 'hover';
+export type DialColor = 'neutral' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+export interface DialMenuProps {
+    /** Open state (v-model) */
+    modelValue?: boolean;
+    /** Animation pattern for action buttons */
+    pattern?: DialPattern;
+    /** Direction actions fan out (for linear) or arc center direction */
+    direction?: DialDirection;
+    /** Arc spread angle in degrees (for arc pattern) */
+    arcSpread?: number;
+    /** Fixed position on screen */
+    placement?: DialPlacement;
+    /** Gap/radius between action buttons (in rem) */
+    gap?: number;
+    /** Trigger interaction mode */
+    trigger?: DialTriggerMode;
+    /** Disable the entire menu */
+    disabled?: boolean;
+}
+export interface DialTriggerProps {
+    /** Whether the menu is open */
+    open?: boolean;
+    /** Disable the trigger */
+    disabled?: boolean;
+}
+export interface DialActionProps {
+    /** Icon name for the action */
+    icon?: string;
+    /** Accessible label (required for accessibility) */
+    label: string;
+    /** Color variant */
+    color?: DialColor;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Tooltip text shown on hover */
+    tooltip?: string;
+}
+export declare const DIAL_MENU_INJECTION_KEY: InjectionKey<DialMenuContext>;
+export interface DialMenuContext {
+    /** Register an action and get its index */
+    registerAction: () => number;
+    /** Unregister an action */
+    unregisterAction: (index: number) => void;
+    /** Total number of registered actions */
+    actionCount: Ref<number>;
+    /** Current pattern */
+    pattern: Ref<DialPattern>;
+    /** Current direction */
+    direction: Ref<DialDirection>;
+    /** Gap between actions */
+    gap: Ref<number>;
+    /** Arc spread angle */
+    arcSpread: Ref<number>;
+    /** Whether menu is open */
+    isOpen: Ref<boolean>;
+    /** Close the menu */
+    close: () => void;
+}

package/dist/components/Dropdown/Dropdown.vue.d.ts

@@ -34,8 +34,8 @@ declare const __VLS_component: import('vue').DefineComponent<DropdownProps, {
     isDisabled: boolean;
     trigger: import('./types').DropdownTriggerMode;
     strategy: import('./types').DropdownStrategy;
-    closeOnSelect: boolean;
     offset: number;
+    closeOnSelect: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/LineChart/LineChart.vue.d.ts

@@ -49,11 +49,11 @@ declare const __VLS_component: import('vue').DefineComponent<LineChartProps, {},
     showTooltip: boolean;
     animated: boolean;
     animationDuration: number;
+    strokeWidth: number;
     curve: import('./types').LineChartCurve;
     areaOpacity: number;
     showPoints: boolean;
     pointRadius: number;
-    strokeWidth: number;
     showToolbar: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     containerRef: HTMLDivElement;

package/dist/components/LineChart/LineChartPath.vue.d.ts

@@ -23,12 +23,12 @@ declare const _default: import('vue').DefineComponent<LineChartPathProps, {}, {}
     animated: boolean;
     animationDuration: number;
     hoveredIndex: number | null;
+    strokeWidth: number;
     dashed: boolean;
     curve: LineChartCurve;
     areaOpacity: number;
     showPoints: boolean;
     pointRadius: number;
-    strokeWidth: number;
     baseline: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     pathRef: SVGPathElement;

package/dist/components/Modal/Modal.vue.d.ts

@@ -34,6 +34,8 @@ declare const __VLS_component: import('vue').DefineComponent<ModalProps, {
     closeOnEscape: boolean;
     closeOnBackdrop: boolean;
     preventScroll: boolean;
+    backdrop: boolean;
+    floating: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     dialogRef: HTMLDialogElement;
 }, HTMLDialogElement>;

package/dist/components/Modal/types.d.ts

@@ -17,4 +17,8 @@ export interface ModalProps {
     closeOnEscape?: boolean;
     /** Prevent body scroll when modal is open */
     preventScroll?: boolean;
+    /** Show backdrop overlay (disabling also enables body scrolling) */
+    backdrop?: boolean;
+    /** Float the drawer with rounded corners and margin on all sides (drawer placements only) */
+    floating?: boolean;
 }

package/dist/components/Navbar/Navbar.vue.d.ts

@@ -14,9 +14,9 @@ declare const __VLS_component: import('vue').DefineComponent<NavbarProps, {}, {}
     height: NavbarHeight;
     blur: boolean;
     transparent: boolean;
+    maxWidth: import('./types').NavbarMaxWidth;
     hideOnScroll: boolean;
     scrollThreshold: number;
-    maxWidth: import('./types').NavbarMaxWidth;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Navbar/NavbarMenu.vue.d.ts

@@ -4,6 +4,7 @@ declare function __VLS_template(): {
     slots: {
         trigger?(_: {}): any;
         default?(_: {}): any;
+        default?(_: {}): any;
     };
     refs: {
         triggerRef: HTMLButtonElement;
@@ -14,11 +15,11 @@ declare function __VLS_template(): {
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<NavbarMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<NavbarMenuProps> & Readonly<{}>, {
     trigger: import('./types').NavbarMenuTrigger;
-    fullWidth: boolean;
+    columns: NavbarMenuColumns;
     offset: number;
+    fullWidth: boolean;
     openDelay: number;
     closeDelay: number;
-    columns: NavbarMenuColumns;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     triggerRef: HTMLButtonElement;
     panelRef: HTMLDivElement;

package/dist/components/SearchInput/SearchInput.vue.d.ts

@@ -0,0 +1,40 @@
+import { SearchInputProps, SearchInputSize, SearchResult } from './types';
+declare function expand(): void;
+declare function collapse(): void;
+declare const _default: import('vue').DefineComponent<SearchInputProps, {
+    expand: typeof expand;
+    collapse: typeof collapse;
+    focus: () => void | undefined;
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (query: string) => any;
+    clear: () => any;
+    "update:modelValue": (value: string) => any;
+    select: (result: SearchResult) => any;
+    expand: () => any;
+    collapse: () => any;
+}, string, import('vue').PublicProps, Readonly<SearchInputProps> & Readonly<{
+    onSearch?: ((query: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onSelect?: ((result: SearchResult) => any) | undefined;
+    onExpand?: (() => any) | undefined;
+    onCollapse?: (() => any) | undefined;
+}>, {
+    size: SearchInputSize;
+    disabled: boolean;
+    loading: boolean;
+    placeholder: string;
+    clearable: boolean;
+    minQueryLength: number;
+    debounceMs: number;
+    expanded: boolean;
+    collapsible: boolean;
+    collapseOnBlur: boolean;
+    noResultsText: string;
+    maxResults: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    wrapperRef: HTMLDivElement;
+    inputRef: HTMLInputElement;
+}, any>;
+export default _default;

package/dist/components/SearchInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SearchInput } from './SearchInput.vue';
+export type { SearchInputProps, SearchInputSize, SearchResult, } from './types';

package/dist/components/SearchInput/types.d.ts

@@ -0,0 +1,48 @@
+import { Component } from 'vue';
+export type SearchInputSize = 'sm' | 'md' | 'lg';
+export interface SearchResult {
+    /** Unique identifier for the result */
+    id: string | number;
+    /** Display label for the result */
+    label: string;
+    /** Optional description shown below the label */
+    description?: string;
+    /** Optional icon (name string or Component) */
+    icon?: string | Component;
+    /** Whether this result is disabled */
+    disabled?: boolean;
+    /** Additional data to pass through on selection */
+    data?: unknown;
+}
+export interface SearchInputProps {
+    /** v-model value for the search query */
+    modelValue?: string;
+    /** Placeholder text when input is empty */
+    placeholder?: string;
+    /** Size variant */
+    size?: SearchInputSize;
+    /** Disable the input */
+    disabled?: boolean;
+    /** Show clear button when input has value */
+    clearable?: boolean;
+    /** Start in expanded state (only applies when collapsible is true) */
+    expanded?: boolean;
+    /** Enable collapsible pill behavior (default: true). When false, input is always expanded */
+    collapsible?: boolean;
+    /** Collapse back to icon when clicking outside (only applies when collapsible is true) */
+    collapseOnBlur?: boolean;
+    /** Array of search results to display */
+    results?: SearchResult[];
+    /** Show loading spinner in dropdown */
+    loading?: boolean;
+    /** Debounce delay for search event in milliseconds */
+    debounceMs?: number;
+    /** Minimum characters before showing results */
+    minQueryLength?: number;
+    /** Text to show when no results found */
+    noResultsText?: string;
+    /** Maximum number of results to display */
+    maxResults?: number;
+    /** Width of expanded input (CSS value) */
+    expandedWidth?: string;
+}

package/dist/components/Sparkline/Sparkline.vue.d.ts

@@ -14,10 +14,10 @@ declare const _default: import('vue').DefineComponent<SparklineProps, {}, {}, {}
     showTooltip: boolean;
     animated: boolean;
     animationDuration: number;
+    fillOpacity: number;
+    strokeWidth: number;
     responsive: boolean;
     curve: import('./types').SparklineCurve;
-    strokeWidth: number;
-    fillOpacity: number;
     highlightOnHover: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     containerRef: HTMLDivElement;

package/dist/components/Sparkline/SparklineLine.vue.d.ts

@@ -14,9 +14,9 @@ declare const _default: import('vue').DefineComponent<SparklineLineProps, {}, {}
     area: boolean;
     animated: boolean;
     animationDuration: number;
+    strokeWidth: number;
     curve: SparklineCurve;
     areaOpacity: number;
-    strokeWidth: number;
     baseline: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     pathRef: SVGPathElement;

package/dist/components/Table/Table.vue.d.ts

@@ -35,11 +35,12 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
     rowHeight: number;
     overscan: number;
     emptyMessage: string;
+    animated: boolean;
+    maxHeight: string;
+    columns: ColumnDefinition<Record<string, unknown>>[];
     hoverable: boolean;
     selectionMode: import('./types').SelectionMode;
     selectedKeys: Set<string | number> | Array<string | number>;
-    maxHeight: string;
-    columns: ColumnDefinition<Record<string, unknown>>[];
     rowKey: string | ((row: Record<string, unknown>, index: number) => string | number);
     sortState: SortState;
     stickyHeader: boolean;

package/dist/components/Table/types.d.ts

@@ -74,6 +74,8 @@ export interface TableProps<T = Record<string, unknown>> {
     overscan?: number;
     /** Enable client-side sorting using column sortFn or default string comparison */
     clientSideSorting?: boolean;
+    /** Enable row animations for sorting, filtering, add/remove (default: true) */
+    animated?: boolean;
 }
 export interface TableHeaderProps {
     /** Enable sticky positioning */
@@ -213,5 +215,7 @@ export interface TableContext<T = Record<string, unknown>> {
     getRowKey: (row: T, index: number) => string | number;
     /** Unique table ID for ARIA */
     tableId: string;
+    /** Row animations enabled */
+    animated: Ref<boolean>;
 }
 export declare const TABLE_INJECTION_KEY: InjectionKey<TableContext>;

package/dist/components/Timer/Timer.vue.d.ts

@@ -0,0 +1,60 @@
+import { TimerProps, TimerFormat, TimerSize } from './types';
+declare function start(): void;
+declare function pause(): void;
+declare function reset(): void;
+declare function toggle(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        display?(_: {
+            time: number;
+            formatted: string;
+        }): any;
+        controls?(_: {
+            start: typeof start;
+            pause: typeof pause;
+            reset: typeof reset;
+            toggle: typeof toggle;
+            isRunning: boolean;
+            currentTime: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TimerProps, {
+    start: typeof start;
+    pause: typeof pause;
+    reset: typeof reset;
+    toggle: typeof toggle;
+    isRunning: import('vue').Ref<boolean, boolean>;
+    currentTime: import('vue').Ref<number, number>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reset: () => any;
+    start: () => any;
+    pause: () => any;
+    tick: (time: number) => any;
+    complete: () => any;
+}, string, import('vue').PublicProps, Readonly<TimerProps> & Readonly<{
+    onReset?: (() => any) | undefined;
+    onStart?: (() => any) | undefined;
+    onPause?: (() => any) | undefined;
+    onTick?: ((time: number) => any) | undefined;
+    onComplete?: (() => any) | undefined;
+}>, {
+    size: TimerSize;
+    animated: boolean;
+    mode: import('./types').TimerMode;
+    format: TimerFormat;
+    duration: number;
+    autoStart: boolean;
+    showControls: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Timer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Timer } from './Timer.vue';
+export type { TimerProps, TimerMode, TimerFormat, TimerSize } from './types';

package/dist/components/Timer/types.d.ts

@@ -0,0 +1,19 @@
+export type TimerMode = 'stopwatch' | 'countdown';
+export type TimerFormat = 'auto' | 'ss' | 'mm:ss' | 'hh:mm:ss';
+export type TimerSize = 'sm' | 'md' | 'lg' | 'xl';
+export interface TimerProps {
+    /** Timer mode */
+    mode?: TimerMode;
+    /** Duration in seconds for countdown mode */
+    duration?: number;
+    /** Start automatically on mount */
+    autoStart?: boolean;
+    /** Time display format */
+    format?: TimerFormat;
+    /** Show built-in controls */
+    showControls?: boolean;
+    /** Size variant */
+    size?: TimerSize;
+    /** Enable slide animation on digit changes */
+    animated?: boolean;
+}

package/dist/components/Tree/Tree.vue.d.ts

@@ -0,0 +1,22 @@
+import { TreeProps, TreeNodeId } from './types';
+declare function expandAll(): void;
+declare function collapseAll(): void;
+declare const _default: import('vue').DefineComponent<TreeProps, {
+    expandAll: typeof expandAll;
+    collapseAll: typeof collapseAll;
+    expandedKeys: import('vue').ComputedRef<Set<TreeNodeId> & Omit<Set<TreeNodeId>, keyof Set<any>>>;
+    selectedKeys: import('vue').ComputedRef<Set<TreeNodeId> & Omit<Set<TreeNodeId>, keyof Set<any>>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:selected": (value: TreeNodeId[]) => any;
+    "update:expanded": (value: TreeNodeId[]) => any;
+}, string, import('vue').PublicProps, Readonly<TreeProps> & Readonly<{
+    "onUpdate:selected"?: ((value: TreeNodeId[]) => any) | undefined;
+    "onUpdate:expanded"?: ((value: TreeNodeId[]) => any) | undefined;
+}>, {
+    selected: TreeNodeId[];
+    expanded: TreeNodeId[];
+    selectable: boolean;
+    multiSelect: boolean;
+    showLines: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/Tree/TreeNode.vue.d.ts

@@ -0,0 +1,5 @@
+import { TreeNodeProps } from './types';
+declare const _default: import('vue').DefineComponent<TreeNodeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeNodeProps> & Readonly<{}>, {
+    level: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/Tree/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Tree } from './Tree.vue';
+export { default as TreeNode } from './TreeNode.vue';
+export type { TreeNodeData, TreeNodeId, TreeProps, TreeNodeProps, TreeContext, } from './types';