@teammodlr/ui-kit 2.1.4 → 2.1.6

package/lib/call.d.ts

@@ -0,0 +1,7 @@
+declare function call(funcs: MaybeArray<() => void>): void;
+declare function call<A1>(funcs: MaybeArray<(a1: A1) => void>, a1: A1): void;
+declare function call<A1, A2>(funcs: MaybeArray<(a1: A1, a2: A2) => void>, a1: A1, a2: A2): void;
+declare function call<A1, A2, A3>(funcs: MaybeArray<(a1: A1, a2: A2, a3: A3) => void>, a1: A1, a2: A2, a3: A3): void;
+declare function call<A1, A2, A3, A4>(funcs: MaybeArray<(a1: A1, a2: A2, a3: A3, a4: A4) => void>, a1: A1, a2: A2, a3: A3, a4: A4): void;
+export { call };
+export type MaybeArray<T> = T | T[];

package/lib/components/confirm/Confirm.vue.d.ts

@@ -0,0 +1,46 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly title: StringConstructor;
+    readonly closable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly okText: StringConstructor;
+    readonly cancelText: StringConstructor;
+    readonly content: import("vue").PropType<string | (() => import("vue").VNodeChild)>;
+    readonly action: import("vue").PropType<() => import("vue").VNodeChild>;
+    readonly loading: BooleanConstructor;
+    readonly onOk: import("vue").PropType<(e: MouseEvent) => void>;
+    readonly onCancel: import("vue").PropType<(e: MouseEvent) => void>;
+    readonly onClose: import("vue").PropType<() => void>;
+    readonly okVariant: {
+        readonly type: import("vue").PropType<import("../../types/props").Variant>;
+        readonly default: "primary";
+    };
+}, {
+    modal: import("vue").Ref<any>;
+    handleOk: (event: MouseEvent) => Promise<void>;
+    handleCancel: (event: MouseEvent) => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly title: StringConstructor;
+    readonly closable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly okText: StringConstructor;
+    readonly cancelText: StringConstructor;
+    readonly content: import("vue").PropType<string | (() => import("vue").VNodeChild)>;
+    readonly action: import("vue").PropType<() => import("vue").VNodeChild>;
+    readonly loading: BooleanConstructor;
+    readonly onOk: import("vue").PropType<(e: MouseEvent) => void>;
+    readonly onCancel: import("vue").PropType<(e: MouseEvent) => void>;
+    readonly onClose: import("vue").PropType<() => void>;
+    readonly okVariant: {
+        readonly type: import("vue").PropType<import("../../types/props").Variant>;
+        readonly default: "primary";
+    };
+}>>, {
+    readonly loading: boolean;
+    readonly closable: boolean;
+    readonly okVariant: import("../../types/props").Variant;
+}, {}>;
+export default _default;

package/lib/components/{dialog/DialogProvider.vue.d.ts → confirm/ConfirmProvider.vue.d.ts}

@@ -1,5 +1,5 @@
-import type { Dialog, DialogOptions } from "./types";
-interface PrivateDialogRef extends Dialog {
+import type { Confirm, ConfirmOptions } from "./types";
+interface PrivateConfirmRef extends Confirm {
     key: string;
     hide: () => void;
 }
@@ -9,12 +9,12 @@ declare const _default: import("vue").DefineComponent<{
         default: string;
     };
 }, {
-    dialogRefs: Record<string, PrivateDialogRef>;
+    dialogRefs: Record<string, PrivateConfirmRef>;
     dialogList: import("vue").Ref<{
         key: string;
         destroy: () => void;
         title?: string | undefined;
-        render?: import("./types").DialogContentRender | undefined;
+        render?: import("./types").ConfirmContentRender | undefined;
         content: string;
         onClose?: (() => void) | undefined;
         onOpen?: (() => void) | undefined;
@@ -24,7 +24,7 @@ declare const _default: import("vue").DefineComponent<{
         okText?: string | undefined;
         cancelText?: string | undefined;
     }[]>;
-    create: (options: DialogOptions) => Dialog;
+    create: (options: ConfirmOptions) => Confirm;
     destroyAll: () => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     teleportTo: {

package/lib/components/{dialog → confirm}/props.d.ts

@@ -1,6 +1,6 @@
 import type { Variant } from '../../types/props';
 import type { ExtractPropTypes, PropType, VNodeChild } from 'vue';
-export declare const dialogProps: {
+export declare const confirmProps: {
     readonly title: StringConstructor;
     readonly closable: {
         readonly type: BooleanConstructor;
@@ -19,4 +19,4 @@ export declare const dialogProps: {
         readonly default: "primary";
     };
 };
-export type DialogProps = ExtractPropTypes<typeof dialogProps>;
+export type ConfirmProps = ExtractPropTypes<typeof confirmProps>;

package/lib/components/confirm/types.d.ts

@@ -0,0 +1,27 @@
+import type { Variant } from '../../types/props';
+import type { VNodeChild } from 'vue';
+export type ConfirmContentType = string;
+export type ConfirmContentRender = (props: any) => VNodeChild;
+export interface ConfirmOptions {
+    title?: string;
+    render?: ConfirmContentRender;
+    content: ConfirmContentType;
+    onClose?: () => void;
+    onOpen?: () => void;
+    onOk?: () => void;
+    onCancel?: () => void;
+    okVariant?: Variant;
+    okText?: ConfirmContentType;
+    cancelText?: ConfirmContentType;
+}
+export interface ConfirmResponse {
+    result: boolean;
+    data: any;
+}
+export interface ConfirmApiInjection {
+    create: (options: ConfirmOptions) => Confirm;
+    destroyAll: () => void;
+}
+export interface Confirm extends ConfirmOptions {
+    destroy: () => void;
+}

package/lib/components/confirm/useConfirm.d.ts

@@ -0,0 +1,2 @@
+import type { ConfirmApiInjection } from './types';
+export declare function useConfirm(): ConfirmApiInjection;

package/lib/components/dialog/Dialog.vue.d.ts

@@ -1,46 +1,95 @@
+import { type PropType } from "vue";
+import * as style from "./style";
 declare const _default: import("vue").DefineComponent<{
-    readonly title: StringConstructor;
-    readonly closable: {
-        readonly type: BooleanConstructor;
-        readonly default: true;
-    };
-    readonly okText: StringConstructor;
-    readonly cancelText: StringConstructor;
-    readonly content: import("vue").PropType<string | (() => import("vue").VNodeChild)>;
-    readonly action: import("vue").PropType<() => import("vue").VNodeChild>;
-    readonly loading: BooleanConstructor;
-    readonly onOk: import("vue").PropType<(e: MouseEvent) => void>;
-    readonly onCancel: import("vue").PropType<(e: MouseEvent) => void>;
-    readonly onClose: import("vue").PropType<() => void>;
-    readonly okVariant: {
-        readonly type: import("vue").PropType<import("../../types/props").Variant>;
-        readonly default: "primary";
+    title: {
+        type: StringConstructor;
+        default: string;
     };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    backdrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    zIndex: {
+        type: NumberConstructor;
+    };
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    transformOrigin: {
+        type: PropType<"center" | "mouse">;
+        default: string;
+    };
+    focusTrap: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    slots: Readonly<{
+        [name: string]: import("vue").Slot<any> | undefined;
+    }>;
+    wrapper: import("vue").Ref<HTMLElement | null>;
+    dialog: import("vue").Ref<HTMLElement | null>;
+    handle: import("vue").Ref<HTMLElement | null>;
+    zIndex: import("vue").Ref<number>;
+    width: import("vue").ComputedRef<string>;
+    x: import("vue").Ref<number>;
+    y: import("vue").Ref<number>;
+    style: typeof style;
+    backdropClasses: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    nextZIndex: () => number;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("onClose" | "onOpen")[], "onClose" | "onOpen", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    backdrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    zIndex: {
+        type: NumberConstructor;
+    };
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    transformOrigin: {
+        type: PropType<"center" | "mouse">;
+        default: string;
+    };
+    focusTrap: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onOnClose?: ((...args: any[]) => any) | undefined;
+    onOnOpen?: ((...args: any[]) => any) | undefined;
 }, {
-    modal: import("vue").Ref<any>;
-    handleOk: (event: MouseEvent) => Promise<void>;
-    handleCancel: (event: MouseEvent) => Promise<void>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    readonly title: StringConstructor;
-    readonly closable: {
-        readonly type: BooleanConstructor;
-        readonly default: true;
-    };
-    readonly okText: StringConstructor;
-    readonly cancelText: StringConstructor;
-    readonly content: import("vue").PropType<string | (() => import("vue").VNodeChild)>;
-    readonly action: import("vue").PropType<() => import("vue").VNodeChild>;
-    readonly loading: BooleanConstructor;
-    readonly onOk: import("vue").PropType<(e: MouseEvent) => void>;
-    readonly onCancel: import("vue").PropType<(e: MouseEvent) => void>;
-    readonly onClose: import("vue").PropType<() => void>;
-    readonly okVariant: {
-        readonly type: import("vue").PropType<import("../../types/props").Variant>;
-        readonly default: "primary";
-    };
-}>>, {
-    readonly loading: boolean;
-    readonly closable: boolean;
-    readonly okVariant: import("../../types/props").Variant;
+    title: string;
+    width: string | number;
+    draggable: boolean;
+    transformOrigin: "center" | "mouse";
+    onClose: () => void;
+    backdrop: boolean;
+    focusTrap: boolean;
 }, {}>;
 export default _default;

package/lib/components/dialog/style/Dialog.css.d.ts

@@ -0,0 +1,11 @@
+export declare const vars: {};
+export declare const root: string;
+export declare const backdrop: string;
+export declare const backdropColor: string;
+export declare const wrapper: string;
+export declare const dialog: string;
+export declare const content: string;
+export declare const header: string;
+export declare const footer: string;
+export declare const title: string;
+export declare const close: string;

package/lib/components/dialog/style/index.d.ts

@@ -0,0 +1 @@
+export * from './Dialog.css';

package/lib/components/dialog/types.d.ts

@@ -1,27 +0,0 @@
-import type { Variant } from '../../types/props';
-import type { VNodeChild } from 'vue';
-export type DialogContentType = string;
-export type DialogContentRender = (props: any) => VNodeChild;
-export interface DialogOptions {
-    title?: string;
-    render?: DialogContentRender;
-    content: DialogContentType;
-    onClose?: () => void;
-    onOpen?: () => void;
-    onOk?: () => void;
-    onCancel?: () => void;
-    okVariant?: Variant;
-    okText?: DialogContentType;
-    cancelText?: DialogContentType;
-}
-export interface DialogResponse {
-    result: boolean;
-    data: any;
-}
-export interface DialogApiInjection {
-    create: (options: DialogOptions) => Dialog;
-    destroyAll: () => void;
-}
-export interface Dialog extends DialogOptions {
-    destroy: () => void;
-}

package/lib/components/index.d.ts

@@ -40,5 +40,7 @@ export { default as MTextarea } from './textarea/Textarea.vue';
 export { default as MTooltip } from './tooltip/Tooltip.vue';
 export { default as MTransfer } from './transfer/Transfer.vue';
 export { default as MVirtualScroll } from './virtualscroll/VirtualScroll.vue';
+export { default as MConfirm } from './confirm/Confirm.vue';
+export { default as MConfirmProvider } from './confirm/ConfirmProvider.vue';
 export { default as MDialog } from './dialog/Dialog.vue';
-export { default as MDialogProvider } from './dialog/DialogProvider.vue';
+export { default as MTree } from './tree/Tree.vue';

package/lib/components/select/Select.vue.d.ts

@@ -60,6 +60,14 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    selectAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
     modelValue: PropType<string | number | boolean | object | any[] | undefined>;
     name: StringConstructor;
     readonly: BooleanConstructor;
@@ -75,11 +83,12 @@ declare const _default: import("vue").DefineComponent<{
     selectRef: import("vue").Ref<HTMLElement | undefined>;
     popper: import("vue").Ref<HTMLElement | null | undefined>;
     focusSelect: () => void;
-    focusOut: (e: Event) => void;
     id: Readonly<import("vue").Ref<string>>;
     isOpen: import("vue").ComputedRef<boolean>;
     open: import("vue").Ref<boolean>;
     selected: import("vue").WritableComputedRef<any>;
+    selectedMax: import("vue").ComputedRef<any>;
+    selectedCountNotShown: import("vue").ComputedRef<number>;
     computedOptions: import("vue").ComputedRef<{
         value: any;
         label: any;
@@ -120,6 +129,7 @@ declare const _default: import("vue").DefineComponent<{
         enterFrom: string;
         leaveTo: string;
     };
+    toggleAllItems: () => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     label: {
         type: StringConstructor;
@@ -179,6 +189,14 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    selectAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
     modelValue: PropType<string | number | boolean | object | any[] | undefined>;
     name: StringConstructor;
     readonly: BooleanConstructor;
@@ -195,6 +213,7 @@ declare const _default: import("vue").DefineComponent<{
     size: Size;
     multiple: boolean;
     disabled: boolean;
+    max: number;
     loading: boolean;
     readonly: boolean;
     rules: unknown[];
@@ -205,5 +224,6 @@ declare const _default: import("vue").DefineComponent<{
     optionLabel: string;
     consistentWidth: boolean;
     allowBlank: boolean;
+    selectAll: boolean;
 }, {}>;
 export default _default;

package/lib/components/select/style/Select.css.d.ts

@@ -30,4 +30,10 @@ export declare const options: string;
 export declare const option: string;
 export declare const optionFocused: string;
 export declare const optionSelected: string;
+export declare const optionLabel: string;
+export declare const checkAll: string;
+export declare const checkAllButton: string;
+export declare const checkAllButtonActive: string;
+export declare const optionIcon: string;
 export declare const noResults: string;
+export declare const clearable: string;

package/lib/components/tree/Tree.vue.d.ts

@@ -0,0 +1,103 @@
+import type { Key, TreeOption } from "./types";
+declare const _default: import("vue").DefineComponent<{
+    readonly expandedKeys: import("vue").PropType<Key[]>;
+    readonly defaultExpandAll: BooleanConstructor;
+    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 onUpdateIndeterminateKeys: import("vue").PropType<import("../../call").MaybeArray<import("./types").OnUpdateIndeterminateKeys>>;
+    readonly 'onUpdate:indeterminateKeys': import("vue").PropType<import("../../call").MaybeArray<import("./types").OnUpdateIndeterminateKeys>>;
+    readonly onUpdateExpandedKeys: import("vue").PropType<import("../../call").MaybeArray<import("./types").onUpdateExpandedKeys>>;
+    readonly 'onUpdate:expandedKeys': import("vue").PropType<import("../../call").MaybeArray<import("./types").onUpdateExpandedKeys>>;
+    readonly data: {
+        readonly type: import("vue").PropType<import("./types").TreeOptions>;
+        readonly default: () => never[];
+    };
+    readonly checkedKeys: import("vue").PropType<Key[]>;
+    readonly defaultCheckedKeys: {
+        readonly type: import("vue").PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly selectedKeys: import("vue").PropType<Key[]>;
+    readonly defaultSelectedKeys: {
+        readonly type: import("vue").PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly multiple: BooleanConstructor;
+    readonly indent: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly expandOnClick: BooleanConstructor;
+    readonly virtualScroll: BooleanConstructor;
+    readonly nodeProps: import("vue").PropType<import("./types").TreeNodeProps>;
+    readonly getChildren: import("vue").PropType<import("./props").GetChildren>;
+}, {
+    nodesRef: import("vue").ComputedRef<import("treemate").TreeNode<TreeOption, TreeOption, TreeOption>[]>;
+    displayTreeMateRef: import("vue").ComputedRef<import("treemate").TreeMate<TreeOption, TreeOption, TreeOption>>;
+    selfElRef: import("vue").Ref<HTMLDivElement | null>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly expandedKeys: import("vue").PropType<Key[]>;
+    readonly defaultExpandAll: BooleanConstructor;
+    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 onUpdateIndeterminateKeys: import("vue").PropType<import("../../call").MaybeArray<import("./types").OnUpdateIndeterminateKeys>>;
+    readonly 'onUpdate:indeterminateKeys': import("vue").PropType<import("../../call").MaybeArray<import("./types").OnUpdateIndeterminateKeys>>;
+    readonly onUpdateExpandedKeys: import("vue").PropType<import("../../call").MaybeArray<import("./types").onUpdateExpandedKeys>>;
+    readonly 'onUpdate:expandedKeys': import("vue").PropType<import("../../call").MaybeArray<import("./types").onUpdateExpandedKeys>>;
+    readonly data: {
+        readonly type: import("vue").PropType<import("./types").TreeOptions>;
+        readonly default: () => never[];
+    };
+    readonly checkedKeys: import("vue").PropType<Key[]>;
+    readonly defaultCheckedKeys: {
+        readonly type: import("vue").PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly selectedKeys: import("vue").PropType<Key[]>;
+    readonly defaultSelectedKeys: {
+        readonly type: import("vue").PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly multiple: BooleanConstructor;
+    readonly indent: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly expandOnClick: BooleanConstructor;
+    readonly virtualScroll: BooleanConstructor;
+    readonly nodeProps: import("vue").PropType<import("./types").TreeNodeProps>;
+    readonly getChildren: import("vue").PropType<import("./props").GetChildren>;
+}>>, {
+    readonly data: import("./types").TreeOptions;
+    readonly multiple: boolean;
+    readonly defaultExpandAll: boolean;
+    readonly keyField: string;
+    readonly labelField: string;
+    readonly childrenField: string;
+    readonly defaultCheckedKeys: Key[];
+    readonly defaultSelectedKeys: Key[];
+    readonly indent: number;
+    readonly expandOnClick: boolean;
+    readonly virtualScroll: boolean;
+}, {}>;
+export default _default;

package/lib/components/tree/TreeNode.vue.d.ts

@@ -0,0 +1,18 @@
+import { type PropType } from "vue";
+import type { TmNode } from "./types";
+declare const _default: import("vue").DefineComponent<{
+    node: {
+        type: PropType<TmNode>;
+        required: true;
+    };
+}, {
+    selfElRef: import("vue").Ref<HTMLDivElement | null>;
+    handleLineClick: (e: MouseEvent) => void;
+    indentCount: import("vue").ComputedRef<number>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<TmNode>;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _default;

package/lib/components/tree/props.d.ts

@@ -0,0 +1,70 @@
+import type { ExtractPublicPropTypes, PropType } from "vue";
+import type { TreeOptions, Key, TreeNodeProps, OnUpdateIndeterminateKeys, onUpdateExpandedKeys } from "./types";
+import type { TreeMateOptions } from "treemate";
+import type { MaybeArray } from "../../call";
+export declare const treeSharedProps: {
+    readonly expandedKeys: PropType<Key[]>;
+    readonly defaultExpandAll: BooleanConstructor;
+    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 onUpdateIndeterminateKeys: PropType<MaybeArray<OnUpdateIndeterminateKeys>>;
+    readonly 'onUpdate:indeterminateKeys': PropType<MaybeArray<OnUpdateIndeterminateKeys>>;
+    readonly onUpdateExpandedKeys: PropType<MaybeArray<onUpdateExpandedKeys>>;
+    readonly 'onUpdate:expandedKeys': PropType<MaybeArray<onUpdateExpandedKeys>>;
+};
+export declare const treeProps: {
+    readonly expandedKeys: PropType<Key[]>;
+    readonly defaultExpandAll: BooleanConstructor;
+    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 onUpdateIndeterminateKeys: PropType<MaybeArray<OnUpdateIndeterminateKeys>>;
+    readonly 'onUpdate:indeterminateKeys': PropType<MaybeArray<OnUpdateIndeterminateKeys>>;
+    readonly onUpdateExpandedKeys: PropType<MaybeArray<onUpdateExpandedKeys>>;
+    readonly 'onUpdate:expandedKeys': PropType<MaybeArray<onUpdateExpandedKeys>>;
+    readonly data: {
+        readonly type: PropType<TreeOptions>;
+        readonly default: () => never[];
+    };
+    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 multiple: BooleanConstructor;
+    readonly indent: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly expandOnClick: BooleanConstructor;
+    readonly virtualScroll: BooleanConstructor;
+    readonly nodeProps: PropType<TreeNodeProps>;
+    readonly getChildren: PropType<GetChildren>;
+};
+export type TreeProps = ExtractPublicPropTypes<typeof treeProps>;
+export type GetChildren = (option: any) => unknown;
+export declare function createTreeMateOptions<T>(keyField: string, childrenField: string, disabledField: string, getChildren: GetChildren | undefined): TreeMateOptions<T, T, T>;

package/lib/components/tree/types.d.ts

@@ -0,0 +1,53 @@
+import type { HTMLAttributes, Ref, InjectionKey } from "vue";
+import type { TreeNode } from "treemate";
+export type Key = string | number;
+export interface TreeOptionBase {
+    key?: Key;
+    label?: string;
+    children?: TreeOption[];
+}
+export type TreeOption = TreeOptionBase & Record<string, unknown>;
+export type TreeOptions = TreeOption[];
+export type TreeNodeProps = (info: {
+    option: TreeOption;
+}) => HTMLAttributes & Record<string, unknown>;
+export interface TreeInjection {
+    indentRef: Ref<number>;
+    expandOnClickRef: Ref<boolean>;
+    nodePropsRef: Ref<TreeNodeProps | undefined>;
+    handleSwitcherClick: (node: TreeNode<TreeOption>) => void;
+}
+export declare const treeInjectionKey: InjectionKey<TreeInjection>;
+export type TmNode = TreeNode<TreeOption>;
+export type OnUpdateCheckedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
+    node: TreeOption | null;
+    action: 'check' | 'uncheck';
+}) => void;
+export type OnUpdateCheckedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
+    node: TreeOption | null;
+    action: 'check' | 'uncheck';
+}) => void;
+export type OnUpdateIndeterminateKeys = (value: Array<string & number>, option: Array<TreeOption | null>) => void;
+export type OnUpdateIndeterminateKeysImpl = (value: Key[], option: Array<TreeOption | null>) => void;
+export type OnUpdateSelectedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
+    node: TreeOption | null;
+    action: 'select' | 'unselect';
+}) => void;
+export type OnUpdateSelectedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
+    node: TreeOption | null;
+    action: 'select' | 'unselect';
+}) => void;
+export type onUpdateExpandedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
+    node: TreeOption;
+    action: 'expand' | 'collapse';
+} | {
+    node: null;
+    action: 'filter';
+}) => void;
+export type OnUpdateExpandedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
+    node: TreeOption;
+    action: 'expand' | 'collapse';
+} | {
+    node: null;
+    action: 'filter';
+}) => void;

package/lib/composables/index.d.ts

@@ -1,4 +1,4 @@
 export { useMessage } from '../components/messageprovider/useMessage';
-export { useDialog } from '../components/dialog/useDialog';
+export { useConfirm } from '../components/confirm/useConfirm';
 export { usePopper } from './usePopper';
 export { useZIndex } from './useZIndex';

package/lib/composables/useMergedState.d.ts

@@ -0,0 +1,2 @@
+import { type Ref, type ComputedRef } from 'vue';
+export default function useMergedState<T>(controlledStateRef: Ref<T | undefined>, uncontrolledStateRef: Ref<T>): ComputedRef<T>;