ep-craft 0.1.34 → 0.1.35

package/dist/components/transfer/composables/use-computed-data.js

@@ -0,0 +1,26 @@
+import { computed as l } from "vue";
+import { usePropsAlias as o } from "./use-props-alias.js";
+const m = (t) => {
+  const u = o(t), d = l(
+    () => t.data.reduce(
+      (e, a) => (e[a[u.value.key]] = a, e),
+      {}
+    )
+  ), n = l(
+    () => t.data.filter(
+      (e) => !t.modelValue.includes(e[u.value.key])
+    )
+  ), i = l(() => t.targetOrder === "original" ? t.data.filter(
+    (e) => t.modelValue.includes(e[u.value.key])
+  ) : t.modelValue.reduce((e, a) => {
+    const r = d.value[a];
+    return r && e.push(r), e;
+  }, []));
+  return {
+    sourceData: n,
+    targetData: i
+  };
+};
+export {
+  m as useComputedData
+};

package/dist/components/transfer/composables/use-move.d.ts

@@ -0,0 +1,6 @@
+import type { SetupContext } from 'vue';
+import type { TransferCheckedState, TransferDataItem, TransferEmits, TransferProps } from '../transfer';
+export declare const useMove: <T extends TransferDataItem = TransferDataItem>(props: Required<Omit<TransferProps<T>, "filterPlaceholder" | "filterMethod" | "renderContent">>, checkedState: TransferCheckedState, emit: SetupContext<TransferEmits>["emit"]) => {
+    addToLeft: () => void;
+    addToRight: () => void;
+};

package/dist/components/transfer/composables/use-move.js

@@ -0,0 +1,27 @@
+import { UPDATE_MODEL_EVENT as c, CHANGE_EVENT as u } from "../../../constants/event.js";
+import { usePropsAlias as s } from "./use-props-alias.js";
+const E = (i, a, d) => {
+  const o = s(i), n = (e, l, t) => {
+    d(c, e), d(u, e, l, t);
+  };
+  return {
+    addToLeft: () => {
+      const e = i.modelValue.slice();
+      a.rightChecked.forEach((l) => {
+        const t = e.indexOf(l);
+        t > -1 && e.splice(t, 1);
+      }), n(e, "left", a.rightChecked);
+    },
+    addToRight: () => {
+      let e = i.modelValue.slice();
+      const l = i.data.filter((t) => {
+        const r = t[o.value.key];
+        return a.leftChecked.includes(r) && !i.modelValue.includes(r);
+      }).map((t) => t[o.value.key]);
+      e = i.targetOrder === "unshift" ? l.concat(e) : e.concat(l), i.targetOrder === "original" && (e = i.data.filter((t) => e.includes(t[o.value.key])).map((t) => t[o.value.key])), n(e, "right", a.leftChecked);
+    }
+  };
+};
+export {
+  E as useMove
+};

package/dist/components/transfer/composables/use-props-alias.d.ts

@@ -0,0 +1,8 @@
+import type { TransferPropsAlias } from '../transfer';
+export declare const usePropsAlias: (props: {
+    props?: TransferPropsAlias;
+}) => import("vue").ComputedRef<{
+    label: string;
+    key: string;
+    disabled: string;
+}>;

package/dist/components/transfer/composables/use-props-alias.js

@@ -0,0 +1,15 @@
+import { computed as s } from "vue";
+const l = (e) => {
+  const o = {
+    label: "label",
+    key: "key",
+    disabled: "disabled"
+  };
+  return s(() => ({
+    ...o,
+    ...e.props
+  }));
+};
+export {
+  l as usePropsAlias
+};

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

@@ -1,4 +1,21 @@
 import type { Plugin } from 'vue';
-import { ElTransfer } from 'element-plus';
-export declare const EpTransfer: typeof ElTransfer & Plugin;
+import _EpTransfer from './EpTransfer.vue';
+/**
+ * transfer 自持 barrel（vendor-batch-2 产出）。
+ *
+ * 本体来自本地 `EpTransfer.vue`，内层面板为内部组件 `EpTransferPanel.vue`
+ * （不对外注册）。表单耦合经本地 `useFormItem()` 读取本地 form 中枢：
+ * `modelValue` 变化时按 `validateEvent` 触发 `validate('change')`。
+ * 迁移前包装态读的是 element-plus 包内 Symbol，校验静默失效。
+ *
+ * 内层依赖接缝：
+ * - Button / Checkbox / CheckboxGroup 使用**默认导入**（本地 barrel 无同名
+ *   具名 `El*` 导出）；Input / FixedSizeList 保持具名导入。
+ * - `use-check.ts` 的类型按本地 barrel 拆分到 checkbox 与 checkbox-group。
+ *
+ * 不导出 `ElTransfer` 别名。
+ */
+export declare const EpTransfer: typeof _EpTransfer & Plugin;
 export default EpTransfer;
+export { LEFT_CHECK_CHANGE_EVENT, RIGHT_CHECK_CHANGE_EVENT, transferCheckedChangeFn, transferEmits, transferProps, } from './transfer';
+export type { TransferCheckedState, TransferDataItem, TransferDirection, TransferEmits, TransferFormat, TransferInstance, TransferKey, TransferProps, TransferPropsAlias, TransferPropsPublic, renderContent, } from './transfer';

package/dist/components/transfer/index.js

@@ -1,6 +1,15 @@
-import { ElTransfer as r } from "element-plus";
-import { withInstall as n } from "../../utils/with-install.js";
-const s = Object.assign({}, r, { name: "EpTransfer" }), a = n(s, "ep-transfer");
+import { withInstall as r } from "../../utils/with-install.js";
+import t from "./EpTransfer.vue.js";
+import { LEFT_CHECK_CHANGE_EVENT as o, RIGHT_CHECK_CHANGE_EVENT as a, transferCheckedChangeFn as C, transferEmits as _, transferProps as m } from "./transfer.js";
+const n = r(
+  t,
+  "ep-transfer"
+);
 export {
-  a as EpTransfer
+  n as EpTransfer,
+  o as LEFT_CHECK_CHANGE_EVENT,
+  a as RIGHT_CHECK_CHANGE_EVENT,
+  C as transferCheckedChangeFn,
+  _ as transferEmits,
+  m as transferProps
 };

package/dist/components/transfer/transfer-panel.d.ts

@@ -0,0 +1,63 @@
+import type { ComponentInstance, ExtractPublicPropTypes, VNode } from 'vue';
+import type { ComponentExposed } from 'vue-component-type-helpers';
+import type { TransferDataItem, TransferFormat, TransferKey, TransferPropsAlias } from './transfer';
+import type TransferPanel from './EpTransferPanel.vue';
+export interface TransferPanelState {
+    checked: TransferKey[];
+    allChecked: boolean;
+    query: string;
+    checkChangeByUser: boolean;
+}
+export declare const CHECKED_CHANGE_EVENT = "checked-change";
+export interface TransferPanelProps<T extends TransferDataItem = TransferDataItem> {
+    data?: T[];
+    optionRender?: (option: T) => VNode | VNode[];
+    placeholder?: string;
+    title?: string;
+    filterable?: boolean;
+    format?: TransferFormat;
+    filterMethod?: (query: string, item: T) => boolean;
+    defaultChecked?: TransferKey[];
+    props?: TransferPropsAlias;
+    virtualScroll?: boolean;
+    itemSize?: number;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `TransferPanelProps` instead.
+ */
+export declare const transferPanelProps: {
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferDataItem[]) | (() => TransferDataItem[]) | (((new (...args: any[]) => TransferDataItem[]) | (() => TransferDataItem[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly optionRender: {
+        readonly type: import("vue").PropType<(option: TransferDataItem) => VNode | VNode[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly placeholder: StringConstructor;
+    readonly title: StringConstructor;
+    readonly filterable: BooleanConstructor;
+    readonly format: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferFormat) | (() => TransferFormat) | (((new (...args: any[]) => TransferFormat) | (() => TransferFormat)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly filterMethod: {
+        readonly type: import("vue").PropType<(query: string, item: TransferDataItem) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultChecked: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferKey[]) | (() => TransferKey[]) | (((new (...args: any[]) => TransferKey[]) | (() => TransferKey[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferPropsAlias) | (() => TransferPropsAlias) | (((new (...args: any[]) => TransferPropsAlias) | (() => TransferPropsAlias)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{
+        readonly label: "label";
+        readonly key: "key";
+        readonly disabled: "disabled";
+    }>, boolean>;
+    readonly virtualScroll: BooleanConstructor;
+    readonly itemSize: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 30, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `TransferPanelProps` instead.
+ */
+export type TransferPanelPropsPublic = ExtractPublicPropTypes<typeof transferPanelProps>;
+export declare const transferPanelEmits: {
+    "checked-change": (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+};
+export type TransferPanelEmits = typeof transferPanelEmits;
+export type TransferPanelInstance = ComponentInstance<typeof TransferPanel> & ComponentExposed<typeof TransferPanel>;

package/dist/components/transfer/transfer-panel.js

@@ -0,0 +1,32 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as t, definePropType as r } from "../../utils/vue/props/runtime.js";
+import "vue";
+import { transferProps as e, transferCheckedChangeFn as o } from "./transfer.js";
+const i = "checked-change";
+t({
+  data: e.data,
+  optionRender: {
+    type: r(
+      Function
+    )
+  },
+  placeholder: String,
+  title: String,
+  filterable: Boolean,
+  format: e.format,
+  filterMethod: e.filterMethod,
+  defaultChecked: e.leftDefaultChecked,
+  props: e.props,
+  virtualScroll: e.virtualScroll,
+  itemSize: e.itemSize
+});
+const c = {
+  [i]: o
+};
+export {
+  i as CHECKED_CHANGE_EVENT,
+  c as transferPanelEmits
+};

package/dist/components/transfer/transfer.d.ts

@@ -0,0 +1,136 @@
+import type { ComponentInstance, ExtractPublicPropTypes, h as H, VNode } from 'vue';
+import type { ComponentExposed } from 'vue-component-type-helpers';
+import type Transfer from './EpTransfer.vue';
+export type TransferKey = string | number;
+export type TransferDirection = 'left' | 'right';
+export type TransferDataItem = Record<string, any>;
+export type renderContent<T extends TransferDataItem = TransferDataItem> = (h: typeof H, option: T) => VNode | VNode[];
+export interface TransferFormat {
+    noChecked?: string;
+    hasChecked?: string;
+}
+export interface TransferPropsAlias {
+    label?: string;
+    key?: string;
+    disabled?: string;
+}
+export interface TransferCheckedState {
+    leftChecked: TransferKey[];
+    rightChecked: TransferKey[];
+}
+export declare const LEFT_CHECK_CHANGE_EVENT = "left-check-change";
+export declare const RIGHT_CHECK_CHANGE_EVENT = "right-check-change";
+export interface TransferProps<T extends TransferDataItem = TransferDataItem> {
+    /**
+     * @description data source
+     */
+    data?: T[];
+    /**
+     * @description custom list titles
+     */
+    titles?: [string, string];
+    /**
+     * @description custom button texts
+     */
+    buttonTexts?: [string, string];
+    /**
+     * @description placeholder for the filter input
+     */
+    filterPlaceholder?: string;
+    /**
+     * @description custom filter method
+     */
+    filterMethod?: (query: string, item: T) => boolean;
+    /**
+     * @description key array of initially checked data items of the left list
+     */
+    leftDefaultChecked?: TransferKey[];
+    /**
+     * @description key array of initially checked data items of the right list
+     */
+    rightDefaultChecked?: TransferKey[];
+    /**
+     * @description custom render function for data items
+     */
+    renderContent?: renderContent<T>;
+    /**
+     * @description binding value
+     */
+    modelValue?: TransferKey[];
+    /**
+     * @description texts for checking status in list header
+     */
+    format?: TransferFormat;
+    /**
+     * @description whether Transfer is filterable
+     */
+    filterable?: boolean;
+    /**
+     * @description prop aliases for data source
+     */
+    props?: TransferPropsAlias;
+    /**
+     * @description order strategy for elements in the target list. If set to `original`, the elements will keep the same order as the data source. If set to `push`, the newly added elements will be pushed to the bottom. If set to `unshift`, the newly added elements will be inserted on the top
+     */
+    targetOrder?: 'original' | 'push' | 'unshift';
+    /**
+     * @description whether to trigger form validation
+     */
+    validateEvent?: boolean;
+    /**
+     * @description whether to enable virtual scrolling
+     */
+    virtualScroll?: boolean;
+    /**
+     * @description line height for virtual scrolling
+     */
+    itemSize?: number;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `TransferProps` instead.
+ */
+export declare const transferProps: {
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferDataItem[]) | (() => TransferDataItem[]) | (((new (...args: any[]) => TransferDataItem[]) | (() => TransferDataItem[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly titles: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | (((new (...args: any[]) => [string, string]) | (() => [string, string])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly buttonTexts: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | (((new (...args: any[]) => [string, string]) | (() => [string, string])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly filterPlaceholder: StringConstructor;
+    readonly filterMethod: {
+        readonly type: import("vue").PropType<(query: string, item: TransferDataItem) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly leftDefaultChecked: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferKey[]) | (() => TransferKey[]) | (((new (...args: any[]) => TransferKey[]) | (() => TransferKey[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly rightDefaultChecked: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferKey[]) | (() => TransferKey[]) | (((new (...args: any[]) => TransferKey[]) | (() => TransferKey[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly renderContent: {
+        readonly type: import("vue").PropType<renderContent<TransferDataItem>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferKey[]) | (() => TransferKey[]) | (((new (...args: any[]) => TransferKey[]) | (() => TransferKey[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly format: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferFormat) | (() => TransferFormat) | (((new (...args: any[]) => TransferFormat) | (() => TransferFormat)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly filterable: BooleanConstructor;
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferPropsAlias) | (() => TransferPropsAlias) | (((new (...args: any[]) => TransferPropsAlias) | (() => TransferPropsAlias)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{
+        readonly label: "label";
+        readonly key: "key";
+        readonly disabled: "disabled";
+    }>, boolean>;
+    readonly targetOrder: import("@element-plus/utils").EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;
+    readonly validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly virtualScroll: BooleanConstructor;
+    readonly itemSize: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 30, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `TransferProps` instead.
+ */
+export type TransferPropsPublic = ExtractPublicPropTypes<typeof transferProps>;
+export declare const transferCheckedChangeFn: (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+export declare const transferEmits: {
+    change: (value: TransferKey[], direction: TransferDirection, movedKeys: TransferKey[]) => boolean;
+    "update:modelValue": (value: TransferKey[]) => boolean;
+    "left-check-change": (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+    "right-check-change": (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+};
+export type TransferEmits = typeof transferEmits;
+export type TransferInstance = ComponentInstance<typeof Transfer> & ComponentExposed<typeof Transfer>;

package/dist/components/transfer/transfer.js

@@ -0,0 +1,130 @@
+import { isNil as i } from "lodash-unified";
+import { isArray as a } from "@vue/shared";
+import "@vueuse/core";
+import { mutable as n } from "../../utils/typescript.js";
+import { UPDATE_MODEL_EVENT as f, CHANGE_EVENT as p } from "../../constants/event.js";
+import "@element-plus/icons-vue";
+import { buildProps as d, definePropType as e } from "../../utils/vue/props/runtime.js";
+import "vue";
+const u = "left-check-change", y = "right-check-change", A = d({
+  /**
+   * @description data source
+   */
+  data: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description custom list titles
+   */
+  titles: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description custom button texts
+   */
+  buttonTexts: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description placeholder for the filter input
+   */
+  filterPlaceholder: String,
+  /**
+   * @description custom filter method
+   */
+  filterMethod: {
+    type: e(
+      Function
+    )
+  },
+  /**
+   * @description key array of initially checked data items of the left list
+   */
+  leftDefaultChecked: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description key array of initially checked data items of the right list
+   */
+  rightDefaultChecked: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description custom render function for data items
+   */
+  renderContent: {
+    type: e(Function)
+  },
+  /**
+   * @description binding value
+   */
+  modelValue: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description texts for checking status in list header
+   */
+  format: {
+    type: e(Object),
+    default: () => ({})
+  },
+  /**
+   * @description whether Transfer is filterable
+   */
+  filterable: Boolean,
+  /**
+   * @description prop aliases for data source
+   */
+  props: {
+    type: e(Object),
+    default: () => n({
+      label: "label",
+      key: "key",
+      disabled: "disabled"
+    })
+  },
+  /**
+   * @description order strategy for elements in the target list. If set to `original`, the elements will keep the same order as the data source. If set to `push`, the newly added elements will be pushed to the bottom. If set to `unshift`, the newly added elements will be inserted on the top
+   */
+  targetOrder: {
+    type: String,
+    values: ["original", "push", "unshift"],
+    default: "original"
+  },
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description whether to enable virtual scrolling
+   */
+  virtualScroll: Boolean,
+  /**
+   * @description line height for virtual scrolling
+   */
+  itemSize: {
+    type: Number,
+    default: 30
+  }
+}), l = (t, r) => [t, r].every(a) || a(t) && i(r), N = {
+  [p]: (t, r, o) => [t, o].every(a) && ["left", "right"].includes(r),
+  [f]: (t) => a(t),
+  [u]: l,
+  [y]: l
+};
+export {
+  u as LEFT_CHECK_CHANGE_EVENT,
+  y as RIGHT_CHECK_CHANGE_EVENT,
+  l as transferCheckedChangeFn,
+  N as transferEmits,
+  A as transferProps
+};

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

@@ -1,4 +1,9 @@
 import type { Plugin } from 'vue';
-import { ElTree } from 'element-plus';
-export declare const EpTree: typeof ElTree & Plugin;
+import _EpTree from './src/tree.vue';
+export declare const EpTree: typeof _EpTree & Plugin;
 export default EpTree;
+export { treeEmits, treeProps } from './src/tree';
+export { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY, } from './src/tokens';
+export type { TreeEmits } from './src/tree';
+export type { TreeInstance } from './src/instance';
+export type { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, DragEvents, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentContext, RenderContentFunction, RootTreeType, TreeComponentProps, TreeData, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType, } from './src/tree.type';

package/dist/components/tree/index.js

@@ -1,6 +1,10 @@
-import { ElTree as e } from "element-plus";
-import { withInstall as r } from "../../utils/with-install.js";
-const t = Object.assign({}, e, { name: "EpTree" }), m = r(t, "ep-tree");
+import { withInstall as e } from "../../utils/with-install.js";
+import r from "./src/tree.vue.js";
+import { treeEmits as f, treeProps as i } from "./src/tree.js";
+const p = e(r, "ep-tree");
 export {
-  m as EpTree
+  p as EpTree,
+  p as default,
+  f as treeEmits,
+  i as treeProps
 };

package/dist/components/tree/src/instance.d.ts

@@ -0,0 +1,2 @@
+import type Tree from './tree.vue';
+export type TreeInstance = InstanceType<typeof Tree> & unknown;

package/dist/components/tree/src/model/node.d.ts

@@ -0,0 +1,63 @@
+import type TreeStore from './tree-store';
+import type { Nullable } from '@element-plus/utils';
+import type { FakeNode, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions } from '../tree.type';
+export declare const getChildState: (node: Node[]) => TreeNodeChildState;
+declare class Node {
+    id: number;
+    text: string | null;
+    checked: boolean;
+    indeterminate: boolean;
+    data: TreeNodeData;
+    expanded: boolean;
+    parent: Node | null;
+    visible: boolean;
+    isCurrent: boolean;
+    store: TreeStore;
+    isLeafByUser: boolean | undefined;
+    isLeaf: boolean | undefined;
+    canFocus: boolean;
+    level: number;
+    loaded: boolean;
+    childNodes: Node[];
+    loading: boolean;
+    /**
+     * Determines whether the current tree node is effectively checked.
+     *
+     * Rules:
+     * 1. A disabled leaf node is always considered checked.
+     * 2. A non-disabled leaf node reflects its actual checked state.
+     * 3. A non-leaf node is considered checked only when:
+     *    - All of its child nodes are effectively checked, and
+     *    - Each child follows the same evaluation rules:
+     *      - Disabled leaf nodes follow rule #1.
+     *      - Non-leaf child nodes are recursively evaluated under this rule (#3).
+     */
+    isEffectivelyChecked: boolean;
+    constructor(options: TreeNodeOptions);
+    initialize(): void;
+    setData(data: TreeNodeData): void;
+    get label(): string;
+    get key(): TreeKey | null | undefined;
+    get disabled(): boolean;
+    get nextSibling(): Nullable<Node>;
+    get previousSibling(): Nullable<Node>;
+    contains(target: Node, deep?: boolean): boolean;
+    remove(): void;
+    insertChild(child?: FakeNode | Node, index?: number, batch?: boolean): void;
+    insertBefore(child: FakeNode | Node, ref: Node): void;
+    insertAfter(child: FakeNode | Node, ref: Node): void;
+    removeChild(child: Node): void;
+    removeChildByData(data: TreeNodeData | null): void;
+    expand(callback?: (() => void) | null, expandParent?: boolean): void;
+    doCreateChildren(array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps): void;
+    collapse(): void;
+    shouldLoadData(): boolean;
+    updateLeafState(): void;
+    setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void;
+    getChildren(forceInit?: boolean): TreeNodeData | TreeNodeData[] | null;
+    updateChildren(): void;
+    loadData(callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps): void;
+    eachNode(callback: (node: Node) => void): void;
+    reInitChecked(): void;
+}
+export default Node;