@ximatai/muyun-web-app 0.26.11 → 0.26.13

package/dist/types/views/usePageCompositionPreviewDrag.d.ts

@@ -0,0 +1,48 @@
+import { type Ref } from 'vue';
+import { type CompositionContainer, type CompositionPlacementSource, type CompositionPlacementTarget, type PageCompositionStructure } from './pageCompositionPlacement';
+export interface PreviewPlacementEntry {
+    title: string;
+    container: CompositionContainer;
+    nodeId?: string;
+    /** Field receivers on a group/child-table heading, distinct from moving that whole section. */
+    inside?: CompositionContainer;
+    axis?: 'x' | 'y' | 'grid';
+    region?: string;
+}
+export interface PageCompositionPreviewPlacement {
+    source: CompositionPlacementSource;
+    target: CompositionPlacementTarget;
+    placement: {
+        container: CompositionContainer;
+        index: number;
+    };
+    title: string;
+}
+/** Coordinates and feedback belong to the preview adapter; placement legality belongs to the draft. */
+export declare function usePageCompositionPreviewDrag(root: Ref<HTMLElement | undefined>, entries: Ref<Map<string, PreviewPlacementEntry>>, structure: Ref<PageCompositionStructure>, enabled: Ref<boolean>, onDrop: (source: CompositionPlacementSource, target: CompositionPlacementTarget) => void): {
+    handleProps: (key: string, title: string) => {
+        role: string;
+        tabindex: number;
+        'aria-label': string;
+        'aria-disabled': boolean;
+        title: string;
+        'data-composer-drag': string;
+        class: string;
+        onMousedown: (event: MouseEvent) => void;
+        onKeydown: (event: KeyboardEvent) => void;
+        onClick: (event: MouseEvent) => void;
+    };
+    groupOutline: import("vue").ShallowRef<Record<string, string> | undefined, Record<string, string> | undefined>;
+    columnOutline: import("vue").ShallowRef<Record<string, string> | undefined, Record<string, string> | undefined>;
+    draggingKey: import("vue").ComputedRef<string | undefined>;
+    feedback: import("vue").ComputedRef<{
+        rejected: boolean;
+        title: string;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    } | undefined>;
+    transientPlacement: import("vue").ComputedRef<PageCompositionPreviewPlacement | undefined>;
+    abandonPendingPlacement: () => void;
+};

package/dist/types/vue-ui-antdv/components/UiActionButton.vue.d.ts

@@ -19,10 +19,10 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     onClick?: ((event: MouseEvent) => any) | undefined;
 }>, {
     title: string;
-    submit: boolean;
     disabled: boolean;
-    loading: boolean;
     iconName: UiIconName;
+    submit: boolean;
+    loading: boolean;
     emphasis: "primary" | "secondary" | "quiet";
     intent: "normal" | "danger";
     density: "regular" | "compact";

package/dist/types/vue-ui-antdv/components/UiButton.vue.d.ts

@@ -12,6 +12,8 @@ type __VLS_Props = {
     iconPosition?: 'start' | 'end';
     /** Fixed square hit area for compact actions whose content is only an icon. */
     iconOnly?: boolean;
+    /** Lightweight persistent selection for non-primary tools such as search and ordering. */
+    selected?: boolean;
 };
 declare var __VLS_16: {};
 type __VLS_Slots = {} & {
@@ -23,16 +25,17 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     onClick?: ((event: MouseEvent) => any) | undefined;
 }>, {
     type: "default" | "primary" | "dashed" | "link" | "text";
-    title: string;
     danger: boolean;
+    title: string;
+    disabled: boolean;
+    iconName: UiIconName;
     size: "small" | "middle" | "large";
     htmlType: "button" | "submit" | "reset";
-    disabled: boolean;
     loading: boolean;
     ariaLabel: string;
-    iconName: UiIconName;
     iconPosition: "start" | "end";
     iconOnly: boolean;
+    selected: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/vue-ui-antdv/components/UiDataTable.vue.d.ts

@@ -16,6 +16,11 @@ type __VLS_Props = {
     showActionColumn?: boolean;
     actionColumnTitle?: string;
     actionColumnWidth?: string | number;
+    /** Compact embedded lists can keep actions in flow instead of forcing horizontal scrolling. */
+    actionColumnFixed?: boolean;
+    /** Enables the adapter's generic row-reorder interaction. The owner decides persistence. */
+    rowDraggable?: boolean;
+    rowDragHandleTitle?: string;
     emptyDescription?: string;
 };
 type __VLS_Slots = {
@@ -40,16 +45,27 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     rowClick: (record: UiDataTableRecord, event: MouseEvent) => any;
     rowDblclick: (record: UiDataTableRecord, event: MouseEvent) => any;
     rowExpand: (record: UiDataTableRecord, expanded: boolean) => any;
+    rowDrop: (event: {
+        source: UiDataTableRecord;
+        target: UiDataTableRecord;
+        position: "before" | "after";
+    }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRowClick?: ((record: UiDataTableRecord, event: MouseEvent) => any) | undefined;
     onRowDblclick?: ((record: UiDataTableRecord, event: MouseEvent) => any) | undefined;
     onRowExpand?: ((record: UiDataTableRecord, expanded: boolean) => any) | undefined;
+    onRowDrop?: ((event: {
+        source: UiDataTableRecord;
+        target: UiDataTableRecord;
+        position: "before" | "after";
+    }) => any) | undefined;
 }>, {
     size: "small" | "middle" | "large";
     loading: boolean;
+    selection: UiDataTableSelection;
     pagination: false | UiDataTablePagination;
+    emptyDescription: string;
     rowKey: string | ((record: UiDataTableRecord) => string);
-    selection: UiDataTableSelection;
     selectedRowKey: string;
     expandedRowKeys: string[];
     clickableRows: boolean;
@@ -59,7 +75,9 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     showActionColumn: boolean;
     actionColumnTitle: string;
     actionColumnWidth: string | number;
-    emptyDescription: string;
+    actionColumnFixed: boolean;
+    rowDraggable: boolean;
+    rowDragHandleTitle: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/vue-ui-antdv/components/UiIcon.vue.d.ts

@@ -1,4 +1,4 @@
-export type UiIconName = 'app' | 'check' | 'close' | 'delete' | 'download' | 'down' | 'edit' | 'export' | 'filter' | 'help' | 'left' | 'lock' | 'menu-collapse' | 'menu-expand' | 'minus' | 'notification' | 'open-in-new' | 'plus' | 'pin-off' | 'pin' | 'power' | 'reload' | 'right' | 'save' | 'search' | 'skin' | 'settings' | 'swap';
+export type UiIconName = 'app' | 'check' | 'close' | 'delete' | 'download' | 'down' | 'edit' | 'export' | 'eye' | 'eye-off' | 'filter' | 'help' | 'left' | 'lock' | 'menu-collapse' | 'menu-expand' | 'minus' | 'notification' | 'open-in-new' | 'plus' | 'pin-off' | 'pin' | 'power' | 'reload' | 'right' | 'save' | 'search' | 'skin' | 'settings' | 'swap' | 'swap-vertical' | 'user';
 type __VLS_Props = {
     name: UiIconName;
 };

package/dist/types/vue-ui-antdv/components/UiPopover.vue.d.ts

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    trigger?: 'click' | 'hover' | 'focus';
+    placement?: 'top' | 'topLeft' | 'topRight' | 'right' | 'rightTop' | 'rightBottom' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'leftTop' | 'leftBottom';
+};
+declare var __VLS_8: {}, __VLS_11: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+} & {
+    content?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    trigger: "click" | "hover" | "focus";
+    placement: "top" | "topLeft" | "topRight" | "right" | "rightTop" | "rightBottom" | "bottom" | "bottomLeft" | "bottomRight" | "left" | "leftTop" | "leftBottom";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue-ui-antdv/components/UiRecordExplorerItem.vue.d.ts

@@ -15,9 +15,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     onAction?: ((action: import("../../web-contracts/index.ts").RecordInlineAction) => any) | undefined;
     onClick?: (() => any) | undefined;
 }>, {
+    selected: boolean;
     secondary: string;
     actions: UiRecordInlineAction[];
-    selected: boolean;
     tag: string;
     muted: boolean;
     clickable: boolean;

package/dist/types/vue-ui-antdv/components/UiSearchInput.vue.d.ts

@@ -4,19 +4,33 @@ type __VLS_Props = {
     disabled?: boolean;
     loading?: boolean;
     searchText?: string;
+    /** Uses a compact icon action for browse/filter entry points while preserving standard search semantics. */
+    searchIconOnly?: boolean;
+    /** The displayed text represents an associated record rather than a search draft. */
+    linked?: boolean;
+    unmatched?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    search: (value: string) => any;
+    search: (value: string, source?: "input" | "clear" | undefined) => any;
+    change: (event: Event) => any;
     "update:value": (value: string) => any;
+    blur: (event: FocusEvent) => any;
+    dblclick: (event: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSearch?: ((value: string) => any) | undefined;
+    onSearch?: ((value: string, source?: "input" | "clear" | undefined) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
     "onUpdate:value"?: ((value: string) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onDblclick?: ((event: MouseEvent) => any) | undefined;
 }>, {
     disabled: boolean;
     loading: boolean;
     value: string;
     placeholder: string;
+    unmatched: boolean;
     searchText: string;
+    searchIconOnly: boolean;
+    linked: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/vue-ui-antdv/components/UiSelect.vue.d.ts

@@ -7,24 +7,50 @@ type __VLS_Props = {
     disabled?: boolean;
     allowClear?: boolean;
     showSearch?: boolean;
+    /** Controlled search draft for callers that must resolve typed text on blur. */
+    searchValue?: string;
     filterOption?: boolean;
     loading?: boolean;
+    /** Marks an unresolved free-text draft without changing the selected option value. */
+    unmatched?: boolean;
+    id?: string;
+    ariaLabel?: string;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare var __VLS_11: {};
+type __VLS_Slots = {} & {
+    suffixAction?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     search: (keyword: string) => any;
     "update:value": (value: OptionValue | OptionValueList | null) => any;
+    blur: (event: FocusEvent) => any;
+    "update:searchValue": (value: string) => any;
+    dblclick: (event: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSearch?: ((keyword: string) => any) | undefined;
     "onUpdate:value"?: ((value: OptionValue | OptionValueList | null) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:searchValue"?: ((value: string) => any) | undefined;
+    onDblclick?: ((event: MouseEvent) => any) | undefined;
 }>, {
-    mode: "multiple";
     disabled: boolean;
+    id: string;
+    mode: "multiple";
     loading: boolean;
+    ariaLabel: string;
     value: OptionValue | OptionValueList | null;
     placeholder: string;
     allowClear: boolean;
     showSearch: boolean;
+    searchValue: string;
     filterOption: boolean;
+    unmatched: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue-ui-antdv/components/UiSidePanel.vue.d.ts

@@ -1,8 +1,13 @@
+import { type UiDrawerWidth } from '../drawerWidth';
+import { type UiDrawerCloseGuard, type UiDrawerDismissal } from '../drawerDismissal';
 import { type UiSidePanelScope } from './sidePanelHost';
 type __VLS_Props = {
     open: boolean;
-    width?: number | string;
+    width?: UiDrawerWidth;
+    dismissal?: UiDrawerDismissal;
+    /** @deprecated Use `dismissal` and `beforeClose`. */
     closeOnOutside?: boolean;
+    beforeClose?: UiDrawerCloseGuard;
     scope?: UiSidePanelScope;
 };
 declare var __VLS_11: {};
@@ -17,8 +22,10 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     onAfterClose?: (() => any) | undefined;
 }>, {
     scope: UiSidePanelScope;
-    width: number | string;
+    width: UiDrawerWidth;
+    dismissal: UiDrawerDismissal;
     closeOnOutside: boolean;
+    beforeClose: UiDrawerCloseGuard;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/vue-ui-antdv/components/UiSwitch.vue.d.ts

@@ -13,8 +13,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
     onChange?: ((checked: boolean) => any) | undefined;
 }>, {
-    size: "default" | "small";
     disabled: boolean;
+    size: "default" | "small";
     loading: boolean;
     checked: boolean;
     checkedText: string;

package/dist/types/vue-ui-antdv/components/UiTextArea.vue.d.ts

@@ -1,20 +1,57 @@
+import type { UiDragSource } from '../types';
 type __VLS_Props = {
     value?: string;
     placeholder?: string;
     disabled?: boolean;
     rows?: number;
     maxlength?: number;
+    /** Enables adapter-owned, selection-aware drops without exposing the underlying textarea DOM. */
+    acceptDrop?: (source: UiDragSource) => boolean;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+/** The adapter owns Ant Design DOM details and exposes only selection-aware editing capabilities. */
+declare function selection(): {
+    start: number;
+    end: number;
+};
+declare function focusSelection(start: number, end?: number): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    selection: typeof selection;
+    focusSelection: typeof focusSelection;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:value": (value: string) => any;
+    drop: (event: {
+        source: UiDragSource;
+        selection: {
+            start: number;
+            end: number;
+        };
+        nativeEvent?: Event;
+    }) => any;
+    selection: (selection: {
+        start: number;
+        end: number;
+    }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:value"?: ((value: string) => any) | undefined;
+    onDrop?: ((event: {
+        source: UiDragSource;
+        selection: {
+            start: number;
+            end: number;
+        };
+        nativeEvent?: Event;
+    }) => any) | undefined;
+    onSelection?: ((selection: {
+        start: number;
+        end: number;
+    }) => any) | undefined;
 }>, {
     disabled: boolean;
     value: string;
     placeholder: string;
     maxlength: number;
     rows: number;
+    acceptDrop: (source: UiDragSource) => boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/vue-ui-antdv/components/UiTokenInput.vue.d.ts

@@ -0,0 +1,62 @@
+import type { UiDragSource } from '../types';
+export interface UiTokenInputToken {
+    /** Source positions are always offsets in value, never offsets in label. */
+    start: number;
+    end: number;
+    /** Exact source text to restore when this visual atom is copied or deleted. */
+    source: string;
+    /** Human readable decoration. */
+    label: string;
+    title?: string;
+}
+type __VLS_Props = {
+    value: string;
+    tokens?: readonly UiTokenInputToken[];
+    placeholder?: string;
+    disabled?: boolean;
+    acceptDrop?: (source: UiDragSource) => boolean;
+};
+declare function selection(): {
+    start: number;
+    end: number;
+};
+declare function focusSelection(start: number, end?: number): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    selection: typeof selection;
+    focusSelection: typeof focusSelection;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (value: string) => any;
+    drop: (event: {
+        source: UiDragSource;
+        selection: {
+            start: number;
+            end: number;
+        };
+        nativeEvent?: Event;
+    }) => any;
+    selection: (selection: {
+        start: number;
+        end: number;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+    onDrop?: ((event: {
+        source: UiDragSource;
+        selection: {
+            start: number;
+            end: number;
+        };
+        nativeEvent?: Event;
+    }) => any) | undefined;
+    onSelection?: ((selection: {
+        start: number;
+        end: number;
+    }) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+    acceptDrop: (source: UiDragSource) => boolean;
+    tokens: readonly UiTokenInputToken[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/vue-ui-antdv/components/UiTree.vue.d.ts

@@ -1,38 +1,92 @@
-import type { UiTreeNode } from '../types';
+import type { UiTreeCheckEvent, UiTreeDisplayMode, UiTreeNodeEvent, UiTreeDropEvent, UiTreeLoadRequest, UiTreeLoadResult, UiTreeLoadIntent, UiTreeLoadStrategy, UiTreeNode, UiTreeBranchState, UiDragSource, UiDropOperation, UiTreeChangeReason } from '../types';
 type __VLS_Props = {
     nodes: UiTreeNode[];
+    displayMode?: UiTreeDisplayMode;
     selectedKey?: string;
     expandedKeys?: string[];
-    /** Resolves children only when a non-leaf node is expanded. */
-    loadChildren?: (node: UiTreeNode) => Promise<void>;
-    /** Re-fetches a node's children after it was explicitly collapsed. */
+    checkedKeys?: string[];
+    checkable?: boolean;
+    checkStrictly?: boolean;
+    canCheck?: (node: UiTreeNode) => boolean;
+    loadChildren?: (node: UiTreeNode, request: UiTreeLoadRequest) => Promise<UiTreeLoadResult>;
+    loadStrategy?: UiTreeLoadStrategy;
+    branchStates?: Readonly<Record<string, UiTreeBranchState>>;
     reloadOnReexpand?: boolean;
-    /** Set false only when an empty lazy branch should remain visibly expanded. */
     collapseEmptyLazyBranch?: boolean;
-    /** Keeps the built-in lazy-loading indicator visible long enough to be perceived. */
     minLoadingDurationMs?: number;
-    /** Replaces the current lazy snapshot, including Ant Tree's loaded-node bookkeeping. */
     reloadKey?: number;
+    draggable?: boolean;
+    dragPayloadOf?: (node: UiTreeNode) => unknown;
+    dragPayloadType?: string;
+    dragOperations?: readonly UiDropOperation[];
+    dropOperation?: (source: UiDragSource) => UiDropOperation;
+    canDrag?: (node: UiTreeNode) => boolean;
+    allowDrop?: (event: UiTreeDropEvent) => boolean;
+    motion?: boolean;
+    motionDurationMs?: number;
+    changeReason?: UiTreeChangeReason;
+    emptyDescription?: string;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    refreshNode: (key: string) => Promise<void>;
+    loadMore: (key: string) => Promise<void>;
+    retryNode: (key: string) => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    check: (event: UiTreeCheckEvent) => any;
     action: (action: import("../../web-contracts/index.ts").RecordInlineAction, node: UiTreeNode) => any;
     select: (node: UiTreeNode) => any;
+    drop: (event: UiTreeDropEvent) => any;
     deselect: () => any;
     "unload-children": (node: UiTreeNode) => any;
+    "load-request": (request: UiTreeLoadIntent) => any;
     "update:expandedKeys": (keys: string[]) => any;
+    "update:checkedKeys": (keys: string[]) => any;
+    "drag-start": (event: UiDragSource) => any;
+    "drag-end": (event: {
+        cancelled: boolean;
+    }) => any;
+    "double-click": (event: UiTreeNodeEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCheck?: ((event: UiTreeCheckEvent) => any) | undefined;
     onAction?: ((action: import("../../web-contracts/index.ts").RecordInlineAction, node: UiTreeNode) => any) | undefined;
     onSelect?: ((node: UiTreeNode) => any) | undefined;
+    onDrop?: ((event: UiTreeDropEvent) => any) | undefined;
     onDeselect?: (() => any) | undefined;
     "onUnload-children"?: ((node: UiTreeNode) => any) | undefined;
+    "onLoad-request"?: ((request: UiTreeLoadIntent) => any) | undefined;
     "onUpdate:expandedKeys"?: ((keys: string[]) => any) | undefined;
+    "onUpdate:checkedKeys"?: ((keys: string[]) => any) | undefined;
+    "onDrag-start"?: ((event: UiDragSource) => any) | undefined;
+    "onDrag-end"?: ((event: {
+        cancelled: boolean;
+    }) => any) | undefined;
+    "onDouble-click"?: ((event: UiTreeNodeEvent) => any) | undefined;
 }>, {
+    draggable: boolean;
     selectedKey: string;
+    motion: boolean;
+    displayMode: UiTreeDisplayMode;
     expandedKeys: string[];
-    loadChildren: (node: UiTreeNode) => Promise<void>;
+    checkedKeys: string[];
+    checkable: boolean;
+    checkStrictly: boolean;
+    canCheck: (node: UiTreeNode) => boolean;
+    loadChildren: (node: UiTreeNode, request: UiTreeLoadRequest) => Promise<UiTreeLoadResult>;
+    loadStrategy: UiTreeLoadStrategy;
+    branchStates: Readonly<Record<string, UiTreeBranchState>>;
+    reloadOnReexpand: boolean;
     collapseEmptyLazyBranch: boolean;
     minLoadingDurationMs: number;
     reloadKey: number;
+    dragPayloadOf: (node: UiTreeNode) => unknown;
+    dragPayloadType: string;
+    dragOperations: readonly UiDropOperation[];
+    dropOperation: (source: UiDragSource) => UiDropOperation;
+    canDrag: (node: UiTreeNode) => boolean;
+    allowDrop: (event: UiTreeDropEvent) => boolean;
+    motionDurationMs: number;
+    changeReason: UiTreeChangeReason;
+    emptyDescription: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/vue-ui-antdv/components/UiTreeSelect.vue.d.ts

@@ -13,24 +13,46 @@ type __VLS_Props = {
     disabled?: boolean;
     allowClear?: boolean;
     showSearch?: boolean;
+    /** Controlled search draft for callers that must resolve typed text on blur. */
+    searchValue?: string;
     filterTreeNode?: boolean;
     loading?: boolean;
+    /** Marks an unresolved free-text draft without changing the selected option value. */
+    unmatched?: boolean;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare var __VLS_11: {};
+type __VLS_Slots = {} & {
+    suffixAction?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     search: (keyword: string) => any;
     "update:value": (value: OptionValue | OptionValueList | null) => any;
+    blur: (event: FocusEvent) => any;
+    "update:searchValue": (value: string) => any;
+    dblclick: (event: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSearch?: ((keyword: string) => any) | undefined;
     "onUpdate:value"?: ((value: OptionValue | OptionValueList | null) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:searchValue"?: ((value: string) => any) | undefined;
+    onDblclick?: ((event: MouseEvent) => any) | undefined;
 }>, {
-    mode: "multiple";
     disabled: boolean;
+    mode: "multiple";
     loading: boolean;
     value: OptionValue | OptionValueList | null;
     placeholder: string;
     allowClear: boolean;
     showSearch: boolean;
+    searchValue: string;
+    unmatched: boolean;
     filterTreeNode: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue-ui-antdv/drawerDismissal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The ways a side panel may be dismissed.  The policy controls which user
+ * gestures can initiate a close; a guard decides whether an initiated close
+ * may discard the active business session.
+ */
+export type UiDrawerDismissal = 'explicit' | 'dismissible' | 'guarded';
+export type UiDrawerCloseReason = 'close-button' | 'outside';
+export type UiDrawerCloseGuard = (reason: UiDrawerCloseReason) => boolean | Promise<boolean>;
+export interface UiDrawerDismissalOptions {
+    dismissal?: UiDrawerDismissal;
+    /** @deprecated Compatibility bridge for callers that have not adopted `dismissal`. */
+    closeOnOutside?: boolean;
+    beforeClose?: UiDrawerCloseGuard;
+}
+export declare function resolveUiDrawerDismissal(options: UiDrawerDismissalOptions): UiDrawerDismissal;
+/** A guarded drawer fails closed until its session owner supplies a guard. */
+export declare function allowsUiDrawerOutsideDismissal(options: UiDrawerDismissalOptions): boolean;
+export declare function mayCloseUiDrawer(options: UiDrawerDismissalOptions, reason: UiDrawerCloseReason): Promise<boolean>;

package/dist/types/vue-ui-antdv/drawerWidth.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Stable width tiers for platform drawers.
+ *
+ * Business surfaces should express the space their content needs instead of
+ * coupling themselves to a pixel value. New width needs are added here as a
+ * platform decision, rather than introduced as local numbers.
+ */
+export declare const uiDrawerWidths: {
+    /** Lightweight property or auxiliary settings. */
+    readonly compact: 420;
+    /** A small single-purpose form or configuration. */
+    readonly narrow: 480;
+    /** The normal record detail and form drawer. */
+    readonly standard: 520;
+    /** A configuration surface with a dense table or several form groups. */
+    readonly wide: 760;
+    /** A large relationship management or editing surface. */
+    readonly extraWide: 960;
+};
+export type UiDrawerWidth = keyof typeof uiDrawerWidths;
+export declare function resolveUiDrawerWidth(width: UiDrawerWidth): number;
+export declare function isUiDrawerWidth(width: unknown): width is UiDrawerWidth;