naive-ui 2.24.0 → 2.24.4

package/es/transfer/src/TransferList.d.ts

@@ -499,11 +499,14 @@ declare const _default: import("vue").DefineComponent<{
     }>;
     mergedClsPrefix: import("vue").Ref<string>;
     scrollerInstRef: import("vue").Ref<{
-        scrollTo: import("../../_internal/scrollbar/src/ScrollBar").ScrollTo;
-        sync: () => void;
         containerRef: HTMLElement | null;
         contentRef: HTMLElement | null;
         containerScrollTop: number;
+        syncUnifiedContainer: () => void;
+        scrollTo: import("../../_internal/scrollbar/src/ScrollBar").ScrollTo;
+        sync: () => void;
+        handleMouseEnterWrapper: () => void;
+        handleMouseLeaveWrapper: () => void;
     } | null>;
     vlInstRef: import("vue").Ref<{
         listElRef: HTMLElement;
@@ -513,23 +516,36 @@ declare const _default: import("vue").DefineComponent<{
     syncVLScroller: () => void;
     scrollContainer: () => HTMLElement | null;
     scrollContent: () => HTMLElement | null;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    virtualScroll?: unknown;
-    itemSize?: unknown;
-    options?: unknown;
-    disabled?: unknown;
-    isMounted?: unknown;
-    isInputing?: unknown;
-    source?: unknown;
-} & {
-    source: boolean;
-    disabled: boolean;
-    itemSize: number;
-    virtualScroll: boolean;
-    isMounted: boolean;
-    options: Option[];
-    isInputing: boolean;
-} & {}>, {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    virtualScroll: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    itemSize: {
+        type: NumberConstructor;
+        required: true;
+    };
+    options: {
+        type: PropType<Option[]>;
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    isMounted: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    isInputing: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    source: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
     source: boolean;
 }>;
 export default _default;

package/es/transfer/src/TransferListItem.d.ts

@@ -486,17 +486,24 @@ declare const _default: import("vue").DefineComponent<{
     }>;
     checked: import("vue").ComputedRef<boolean>;
     handleClick: () => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    source?: unknown;
-    label?: unknown;
-    value?: unknown;
-    disabled?: unknown;
-} & {
-    value: string | number;
-    label: string;
-    source: boolean;
-    disabled: boolean;
-} & {}>, {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    source: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
     source: boolean;
     disabled: boolean;
 }>;

package/es/transfer/src/interface.d.ts

@@ -1,4 +1,4 @@
-import { InjectionKey, Ref } from 'vue';
+import { Ref } from 'vue';
 import type { MergedTheme } from '../../_mixins';
 import type { TransferTheme } from '../styles';
 export declare type OptionValue = string | number;
@@ -27,5 +27,5 @@ export interface TransferInjection {
     handleSrcCheckboxClick: (checked: boolean, value: OptionValue) => void;
     handleTgtCheckboxClick: (checked: boolean, value: OptionValue) => void;
 }
-export declare const transferInjectionKey: InjectionKey<TransferInjection>;
+export declare const transferInjectionKey: import("vue").InjectionKey<TransferInjection>;
 export declare type OnUpdateValue = (value: OptionValue[]) => void;

package/es/transfer/src/interface.js

@@ -1 +1,2 @@
-export const transferInjectionKey = Symbol('transfer');
+import { createInjectionKey } from '../../_utils';
+export const transferInjectionKey = createInjectionKey('n-transfer');

package/es/tree/src/MotionWrapper.d.ts

@@ -18,18 +18,23 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<() => void>;
         required: true;
     };
-}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    height?: unknown;
-    nodes?: unknown;
-    mode?: unknown;
-    onAfterEnter?: unknown;
-} & {
-    mode: "collapse" | "expand";
-    onAfterEnter: () => void;
-    clsPrefix: string;
-    nodes: TmNode[];
-} & {
-    height?: number | undefined;
-}>, {}>;
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    height: NumberConstructor;
+    nodes: {
+        type: PropType<TmNode[]>;
+        required: true;
+    };
+    mode: {
+        type: PropType<"collapse" | "expand">;
+        required: true;
+    };
+    onAfterEnter: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>>, {}>;
 export default _default;

package/es/tree/src/Tree.d.ts

@@ -949,11 +949,14 @@ declare const _default: import("vue").DefineComponent<{
         scrollTo: import("vueuc/lib/virtual-list/src/VirtualList").ScrollTo;
     } | null>;
     scrollbarInstRef: import("vue").Ref<{
-        scrollTo: import("../../_internal/scrollbar/src/ScrollBar").ScrollTo;
-        sync: () => void;
         containerRef: HTMLElement | null;
         contentRef: HTMLElement | null;
         containerScrollTop: number;
+        syncUnifiedContainer: () => void;
+        scrollTo: import("../../_internal/scrollbar/src/ScrollBar").ScrollTo;
+        sync: () => void;
+        handleMouseEnterWrapper: () => void;
+        handleMouseLeaveWrapper: () => void;
     } | null>;
     handleFocusout: (e: FocusEvent) => void;
     handleDragLeaveTree: (e: DragEvent) => void;
@@ -975,112 +978,119 @@ declare const _default: import("vue").DefineComponent<{
         '--n-node-text-color-disabled': string;
         '--n-drop-mark-color': string;
     }>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    readonly internalScrollable?: unknown;
-    readonly internalScrollablePadding?: unknown;
-    readonly internalDataTreeMate?: unknown;
-    readonly internalDisplayTreeMate?: unknown;
-    readonly internalHighlightKeySet?: unknown;
-    readonly internalUnifySelectCheck?: unknown;
-    readonly internalHideFilteredNode?: unknown;
-    readonly internalCheckboxFocusable?: unknown;
-    readonly internalFocusable?: unknown;
-    readonly checkStrategy?: unknown;
-    readonly filter?: unknown;
-    readonly defaultExpandAll?: unknown;
-    readonly expandedKeys?: unknown;
-    readonly keyField?: unknown;
-    readonly labelField?: unknown;
-    readonly childrenField?: unknown;
-    readonly defaultExpandedKeys?: unknown;
-    readonly indeterminateKeys?: unknown;
-    readonly onUpdateIndeterminateKeys?: unknown;
-    readonly 'onUpdate:indeterminateKeys'?: unknown;
-    readonly onUpdateExpandedKeys?: unknown;
-    readonly 'onUpdate:expandedKeys'?: unknown;
-    readonly data?: unknown;
-    readonly expandOnDragenter?: unknown;
-    readonly cancelable?: unknown;
-    readonly checkable?: unknown;
-    readonly draggable?: unknown;
-    readonly blockNode?: unknown;
-    readonly blockLine?: unknown;
-    readonly disabled?: unknown;
-    readonly checkedKeys?: unknown;
-    readonly defaultCheckedKeys?: unknown;
-    readonly selectedKeys?: unknown;
-    readonly defaultSelectedKeys?: unknown;
-    readonly remote?: unknown;
-    readonly leafOnly?: unknown;
-    readonly multiple?: unknown;
-    readonly pattern?: unknown;
-    readonly onLoad?: unknown;
-    readonly cascade?: unknown;
-    readonly selectable?: unknown;
-    readonly indent?: unknown;
-    readonly allowDrop?: unknown;
-    readonly animated?: unknown;
-    readonly virtualScroll?: unknown;
-    readonly watchProps?: unknown;
-    readonly renderLabel?: unknown;
-    readonly renderPrefix?: unknown;
-    readonly renderSuffix?: unknown;
-    readonly renderSwitcherIcon?: unknown;
-    readonly onDragenter?: unknown;
-    readonly onDragleave?: unknown;
-    readonly onDragend?: unknown;
-    readonly onDragstart?: unknown;
-    readonly onDragover?: unknown;
-    readonly onDrop?: unknown;
-    readonly onUpdateCheckedKeys?: unknown;
-    readonly 'onUpdate:checkedKeys'?: unknown;
-    readonly onUpdateSelectedKeys?: unknown;
-    readonly 'onUpdate:selectedKeys'?: unknown;
-    readonly theme?: unknown;
-    readonly themeOverrides?: unknown;
-    readonly builtinThemeOverrides?: unknown;
-} & {
-    pattern: string;
-    data: TreeOptions;
-    multiple: boolean;
-    disabled: boolean;
-    draggable: boolean;
-    keyField: string;
-    virtualScroll: boolean;
-    checkable: boolean;
-    animated: boolean;
-    remote: boolean;
-    cascade: boolean;
-    indent: number;
-    labelField: string;
-    childrenField: string;
-    internalScrollable: boolean;
-    checkStrategy: CheckStrategy;
-    leafOnly: boolean;
-    defaultExpandedKeys: Key[];
-    defaultExpandAll: boolean;
-    cancelable: boolean;
-    blockLine: boolean;
-    selectable: boolean;
-    defaultCheckedKeys: Key[];
-    defaultSelectedKeys: Key[];
-    internalUnifySelectCheck: boolean;
-    internalHideFilteredNode: boolean;
-    internalCheckboxFocusable: boolean;
-    internalFocusable: boolean;
-    expandOnDragenter: boolean;
-    blockNode: boolean;
-    allowDrop: AllowDrop;
-} & {
-    filter?: ((pattern: string, node: TreeOption) => boolean) | undefined;
-    onDragend?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragenter?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragleave?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragover?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragstart?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDrop?: MaybeArray<(e: TreeDropInfo) => void> | undefined;
-    onLoad?: OnLoad | undefined;
-    theme?: import("../../_mixins").Theme<"Tree", {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly internalScrollable: BooleanConstructor;
+    readonly internalScrollablePadding: StringConstructor;
+    readonly internalDataTreeMate: PropType<TreeMate<TreeOption, TreeOption, TreeOption>>;
+    readonly internalDisplayTreeMate: PropType<TreeMate<TreeOption, TreeOption, TreeOption>>;
+    readonly internalHighlightKeySet: PropType<Set<Key>>;
+    readonly internalUnifySelectCheck: BooleanConstructor;
+    readonly internalHideFilteredNode: BooleanConstructor;
+    readonly internalCheckboxFocusable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly internalFocusable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly checkStrategy: {
+        readonly type: PropType<CheckStrategy>;
+        readonly default: "all";
+    };
+    readonly filter: PropType<(pattern: string, node: TreeOption) => boolean>;
+    readonly defaultExpandAll: BooleanConstructor;
+    readonly expandedKeys: PropType<Key[]>;
+    readonly keyField: {
+        readonly type: StringConstructor;
+        readonly default: "key";
+    };
+    readonly labelField: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly childrenField: {
+        readonly type: StringConstructor;
+        readonly default: "children";
+    };
+    readonly defaultExpandedKeys: {
+        readonly type: PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly indeterminateKeys: PropType<Key[]>;
+    readonly onUpdateIndeterminateKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:indeterminateKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly onUpdateExpandedKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:expandedKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly data: {
+        readonly type: PropType<TreeOptions>;
+        readonly default: () => never[];
+    };
+    readonly expandOnDragenter: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly cancelable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly checkable: BooleanConstructor;
+    readonly draggable: BooleanConstructor;
+    readonly blockNode: BooleanConstructor;
+    readonly blockLine: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly checkedKeys: PropType<Key[]>;
+    readonly defaultCheckedKeys: {
+        readonly type: PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly selectedKeys: PropType<Key[]>;
+    readonly defaultSelectedKeys: {
+        readonly type: PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly remote: BooleanConstructor;
+    readonly leafOnly: BooleanConstructor;
+    readonly multiple: BooleanConstructor;
+    readonly pattern: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly onLoad: PropType<OnLoad>;
+    readonly cascade: BooleanConstructor;
+    readonly selectable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly indent: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly allowDrop: {
+        readonly type: PropType<AllowDrop>;
+        readonly default: typeof defaultAllowDrop;
+    };
+    readonly animated: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly virtualScroll: BooleanConstructor;
+    readonly watchProps: PropType<("defaultExpandedKeys" | "defaultCheckedKeys" | "defaultSelectedKeys")[]>;
+    readonly renderLabel: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderPrefix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderSuffix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderSwitcherIcon: PropType<RenderSwitcherIcon>;
+    readonly onDragenter: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragleave: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragend: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragstart: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragover: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDrop: PropType<MaybeArray<(e: TreeDropInfo) => void>>;
+    readonly onUpdateCheckedKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:checkedKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly onUpdateSelectedKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:selectedKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly theme: PropType<import("../../_mixins").Theme<"Tree", {
         fontSize: string;
         nodeBorderRadius: string;
         nodeColorHover: string;
@@ -1124,8 +1134,8 @@ declare const _default: import("vue").DefineComponent<{
             color: string;
             colorHover: string;
         }, any>;
-    }> | undefined;
-    themeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
+    }>>;
+    readonly themeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
         fontSize: string;
         nodeBorderRadius: string;
         nodeColorHover: string;
@@ -1169,8 +1179,8 @@ declare const _default: import("vue").DefineComponent<{
             color: string;
             colorHover: string;
         }, any>;
-    }>> | undefined;
-    builtinThemeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
+    }>>>;
+    readonly builtinThemeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
         fontSize: string;
         nodeBorderRadius: string;
         nodeColorHover: string;
@@ -1214,29 +1224,8 @@ declare const _default: import("vue").DefineComponent<{
             color: string;
             colorHover: string;
         }, any>;
-    }>> | undefined;
-    renderLabel?: (({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined;
-    checkedKeys?: Key[] | undefined;
-    expandedKeys?: Key[] | undefined;
-    watchProps?: ("defaultExpandedKeys" | "defaultCheckedKeys" | "defaultSelectedKeys")[] | undefined;
-    "onUpdate:expandedKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-    onUpdateExpandedKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    renderPrefix?: (({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined;
-    renderSuffix?: (({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined;
-    internalScrollablePadding?: string | undefined;
-    internalDataTreeMate?: TreeMate<TreeOption, TreeOption, TreeOption> | undefined;
-    internalDisplayTreeMate?: TreeMate<TreeOption, TreeOption, TreeOption> | undefined;
-    internalHighlightKeySet?: Set<Key> | undefined;
-    indeterminateKeys?: Key[] | undefined;
-    onUpdateIndeterminateKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    "onUpdate:indeterminateKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-    selectedKeys?: Key[] | undefined;
-    renderSwitcherIcon?: RenderSwitcherIcon | undefined;
-    onUpdateCheckedKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    "onUpdate:checkedKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-    onUpdateSelectedKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    "onUpdate:selectedKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-}>, {
+    }>>>;
+}>>, {
     pattern: string;
     data: TreeOptions;
     multiple: boolean;

package/es/tree/src/TreeNode.d.ts

@@ -43,11 +43,14 @@ declare const TreeNode: import("vue").DefineComponent<{
     handleDragLeave: (e: DragEvent) => void;
     handleContentClick: (e: MouseEvent) => void;
     handleSwitcherClick: () => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    tmNode?: unknown;
-} & {
-    clsPrefix: string;
-    tmNode: TmNode;
-} & {}>, {}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    tmNode: {
+        type: PropType<TmNode>;
+        required: true;
+    };
+}>>, {}>;
 export default TreeNode;

package/es/tree/src/TreeNodeCheckbox.d.ts

@@ -174,22 +174,17 @@ declare const _default: import("vue").DefineComponent<{
             } | undefined;
         };
     }>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    focusable?: unknown;
-    disabled?: unknown;
-    checked?: unknown;
-    indeterminate?: unknown;
-    onCheck?: unknown;
-} & {
-    disabled: boolean;
-    checked: boolean;
-    focusable: boolean;
-    clsPrefix: string;
-    indeterminate: boolean;
-} & {
-    onCheck?: ((value: boolean) => void) | undefined;
-}>, {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    focusable: BooleanConstructor;
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    indeterminate: BooleanConstructor;
+    onCheck: PropType<(value: boolean) => void>;
+}>>, {
     disabled: boolean;
     checked: boolean;
     focusable: boolean;

package/es/tree/src/TreeNodeContent.d.ts

@@ -21,24 +21,21 @@ declare const _default: import("vue").DefineComponent<{
     renderSuffix: import("vue").Ref<(({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined>;
     labelField: import("vue").Ref<string>;
     handleClick: (e: MouseEvent) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    disabled?: unknown;
-    checked?: unknown;
-    selected?: unknown;
-    onClick?: unknown;
-    onDragstart?: unknown;
-    tmNode?: unknown;
-} & {
-    disabled: boolean;
-    checked: boolean;
-    selected: boolean;
-    clsPrefix: string;
-    tmNode: TmNode;
-} & {
-    onDragstart?: ((e: DragEvent) => void) | undefined;
-    onClick?: ((e: MouseEvent) => void) | undefined;
-}>, {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    selected: BooleanConstructor;
+    onClick: PropType<(e: MouseEvent) => void>;
+    onDragstart: PropType<(e: DragEvent) => void>;
+    tmNode: {
+        type: PropType<TmNode>;
+        required: true;
+    };
+}>>, {
     disabled: boolean;
     checked: boolean;
     selected: boolean;

package/es/tree/src/TreeNodeSwitcher.d.ts

@@ -8,20 +8,16 @@ declare const _default: import("vue").DefineComponent<{
     hide: BooleanConstructor;
     loading: BooleanConstructor;
     onClick: PropType<(e: MouseEvent) => void>;
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    expanded?: unknown;
-    hide?: unknown;
-    loading?: unknown;
-    onClick?: unknown;
-} & {
-    hide: boolean;
-    expanded: boolean;
-    loading: boolean;
-    clsPrefix: string;
-} & {
-    onClick?: ((e: MouseEvent) => void) | undefined;
-}>, {
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    expanded: BooleanConstructor;
+    hide: BooleanConstructor;
+    loading: BooleanConstructor;
+    onClick: PropType<(e: MouseEvent) => void>;
+}>>, {
     hide: boolean;
     expanded: boolean;
     loading: boolean;

package/es/tree/src/interface.d.ts

@@ -1,5 +1,5 @@
 import { CheckStrategy, TreeNode } from 'treemate';
-import { InjectionKey, Ref, VNodeChild } from 'vue';
+import { Ref, VNodeChild } from 'vue';
 import type { MergedTheme } from '../../_mixins';
 import type { TreeTheme } from '../styles';
 export declare type Key = string | number;
@@ -94,7 +94,7 @@ export interface TreeInjection {
     handleDragOver: (info: InternalDragInfo) => void;
     handleDrop: (info: InternalDropInfo) => void;
 }
-export declare const treeInjectionKey: InjectionKey<TreeInjection>;
+export declare const treeInjectionKey: import("vue").InjectionKey<TreeInjection>;
 export declare type TmNode = TreeNode<TreeOption>;
 export interface MotionData {
     __motion: true;

package/es/tree/src/interface.js

@@ -1 +1,2 @@
-export const treeInjectionKey = Symbol('tree');
+import { createInjectionKey } from '../../_utils';
+export const treeInjectionKey = createInjectionKey('n-tree');