vxe-gantt 3.9.0 → 3.9.2

package/es/gantt/src/gantt-footer.d.ts

@@ -0,0 +1,16 @@
+import { CreateElement } from 'vue';
+import type { VxeGanttViewPrivateMethods, VxeGanttConstructor, VxeGanttPrivateMethods } from '../../../types';
+declare const _default: import("vue/types/vue").ExtendedVue<import("vue").default, unknown, {
+    renderVN(h: CreateElement): import("vue").VNode;
+}, {
+    $xeGantt: import("vxe-pc-ui").VxeComponentBaseOptions & {
+        reactData: import("vxe-pc-ui/types/components/gantt").GanttReactData<any>;
+        internalData: import("vxe-pc-ui/types/components/gantt").GanttInternalData;
+    } & import("vxe-pc-ui/types/components/gantt").VxeGanttMethods<any> & import("vxe-pc-ui/types/components/gantt").VxeGanttPrivateComputed<any> & import("vxe-pc-ui/types/components/gantt").VxeGanttProps<any> & import("vue").default & VxeGanttPrivateMethods<any>;
+    $xeGanttView: import("vxe-pc-ui").VxeComponentBaseOptions & {
+        reactData: import("vxe-pc-ui/types/components/gantt-module").GanttViewReactData;
+        internalData: import("vxe-pc-ui/types/components/gantt-module").GanttViewInternalData;
+        $xeGantt: VxeGanttConstructor;
+    } & import("vxe-pc-ui/types/components/gantt-module").VxeGanttViewMethods & import("vxe-pc-ui/types/components/gantt-module").GanttViewPrivateComputed & import("vxe-pc-ui/types/components/gantt-module").VxeGanttViewProps & import("vue").default & VxeGanttViewPrivateMethods;
+}, unknown>;
+export default _default;

package/es/gantt/src/gantt-footer.js

@@ -1,60 +1,65 @@
-import { defineVxeComponent } from '../../ui/src/comp';
-const sourceType = 'gantt';
-const viewType = 'footer';
-export default defineVxeComponent({
-    name: 'VxeGanttViewHeader',
-    inject: {
-        $xeGantt: {
-            default: null
-        },
-        $xeGanttView: {
-            default: null
-        }
+import { defineVxeComponent } from "../../ui/src/comp";
+const sourceType = "gantt";
+const viewType = "footer";
+var gantt_footer_default = defineVxeComponent({
+  name: "VxeGanttViewHeader",
+  inject: {
+    $xeGantt: {
+      default: null
     },
-    props: {},
-    computed: Object.assign({}, {}),
-    methods: {
-        //
-        // Render
-        //
-        renderVN(h) {
-            const _vm = this;
-            const $xeGantt = _vm.$xeGantt;
-            return h('div', {
-                ref: 'refElem',
-                class: 'vxe-gantt-view--footer-wrapper'
-            }, [
-                h('div', {
-                    ref: 'refHeaderScroll',
-                    class: 'vxe-gantt-view--footer-inner-wrapper',
-                    on: {
-                        contextmenu(evnt) {
-                            $xeGantt.handleTaskFooterContextmenuEvent(evnt, { source: sourceType, type: viewType, $rowIndex: -1 });
-                        }
-                    }
-                }, [])
-            ]);
-        }
-    },
-    mounted() {
-        const _vm = this;
-        const $xeGanttView = _vm.$xeGanttView;
-        const { internalData } = $xeGanttView;
-        const { elemStore } = internalData;
-        const prefix = 'main-footer-';
-        elemStore[`${prefix}wrapper`] = _vm.$refs.refElem;
-        elemStore[`${prefix}scroll`] = _vm.$refs.refHeaderScroll;
-    },
-    destroyed() {
-        const _vm = this;
-        const $xeGanttView = _vm.$xeGanttView;
-        const { internalData } = $xeGanttView;
-        const { elemStore } = internalData;
-        const prefix = 'main-headefooterr-';
-        elemStore[`${prefix}wrapper`] = null;
-        elemStore[`${prefix}scroll`] = null;
-    },
-    render(h) {
-        return this.renderVN(h);
+    $xeGanttView: {
+      default: null
+    }
+  },
+  props: {},
+  computed: {
+    ...{}
+  },
+  methods: {
+    //
+    // Render
+    //
+    renderVN(h) {
+      const _vm = this;
+      const $xeGantt = _vm.$xeGantt;
+      return h("div", {
+        ref: "refElem",
+        class: "vxe-gantt-view--footer-wrapper"
+      }, [
+        h("div", {
+          ref: "refHeaderScroll",
+          class: "vxe-gantt-view--footer-inner-wrapper",
+          on: {
+            contextmenu(evnt) {
+              $xeGantt.handleTaskFooterContextmenuEvent(evnt, { source: sourceType, type: viewType, $rowIndex: -1 });
+            }
+          }
+        }, [])
+      ]);
     }
+  },
+  mounted() {
+    const _vm = this;
+    const $xeGanttView = _vm.$xeGanttView;
+    const { internalData } = $xeGanttView;
+    const { elemStore } = internalData;
+    const prefix = "main-footer-";
+    elemStore[`${prefix}wrapper`] = _vm.$refs.refElem;
+    elemStore[`${prefix}scroll`] = _vm.$refs.refHeaderScroll;
+  },
+  destroyed() {
+    const _vm = this;
+    const $xeGanttView = _vm.$xeGanttView;
+    const { internalData } = $xeGanttView;
+    const { elemStore } = internalData;
+    const prefix = "main-headefooterr-";
+    elemStore[`${prefix}wrapper`] = null;
+    elemStore[`${prefix}scroll`] = null;
+  },
+  render(h) {
+    return this.renderVN(h);
+  }
 });
+export {
+  gantt_footer_default as default
+};

package/es/gantt/src/gantt-header.d.ts

@@ -0,0 +1,16 @@
+import { CreateElement } from 'vue';
+import type { VxeGanttViewPrivateMethods, VxeGanttConstructor, VxeGanttPrivateMethods } from '../../../types';
+declare const _default: import("vue/types/vue").ExtendedVue<import("vue").default, unknown, {
+    renderVN(h: CreateElement): import("vue").VNode;
+}, {
+    $xeGantt: import("vxe-pc-ui").VxeComponentBaseOptions & {
+        reactData: import("vxe-pc-ui/types/components/gantt").GanttReactData<any>;
+        internalData: import("vxe-pc-ui/types/components/gantt").GanttInternalData;
+    } & import("vxe-pc-ui/types/components/gantt").VxeGanttMethods<any> & import("vxe-pc-ui/types/components/gantt").VxeGanttPrivateComputed<any> & import("vxe-pc-ui/types/components/gantt").VxeGanttProps<any> & import("vue").default & VxeGanttPrivateMethods<any>;
+    $xeGanttView: import("vxe-pc-ui").VxeComponentBaseOptions & {
+        reactData: import("vxe-pc-ui/types/components/gantt-module").GanttViewReactData;
+        internalData: import("vxe-pc-ui/types/components/gantt-module").GanttViewInternalData;
+        $xeGantt: VxeGanttConstructor;
+    } & import("vxe-pc-ui/types/components/gantt-module").VxeGanttViewMethods & import("vxe-pc-ui/types/components/gantt-module").GanttViewPrivateComputed & import("vxe-pc-ui/types/components/gantt-module").VxeGanttViewProps & import("vue").default & VxeGanttViewPrivateMethods;
+}, Record<never, any>>;
+export default _default;

package/es/gantt/src/gantt-header.js

@@ -1,179 +1,177 @@
-import { defineVxeComponent } from '../../ui/src/comp';
-import { VxeUI } from '@vxe-ui/core';
-import XEUtils from 'xe-utils';
+import { defineVxeComponent } from "../../ui/src/comp";
+import { VxeUI } from "@vxe-ui/core";
+import XEUtils from "xe-utils";
 const { getI18n } = VxeUI;
-const sourceType = 'gantt';
-const viewType = 'header';
-export default defineVxeComponent({
-    name: 'VxeGanttViewHeader',
-    inject: {
-        $xeGantt: {
-            default: null
-        },
-        $xeGanttView: {
-            default: null
-        }
+const sourceType = "gantt";
+const viewType = "header";
+var gantt_header_default = defineVxeComponent({
+  name: "VxeGanttViewHeader",
+  inject: {
+    $xeGantt: {
+      default: null
     },
-    computed: Object.assign({}, {}),
-    methods: {
-        //
-        // Render
-        //
-        renderVN(h) {
-            const _vm = this;
-            const $xeGantt = _vm.$xeGantt;
-            const $xeGanttView = _vm.$xeGanttView;
-            const reactData = $xeGanttView.reactData;
-            const internalData = $xeGanttView.internalData;
-            const { headerGroups, viewCellWidth } = reactData;
-            const { todayDateMaps, visibleColumn } = internalData;
-            const taskViewOpts = $xeGantt.computeTaskViewOpts;
-            const minScale = $xeGantt.computeMinScale;
-            const scaleStep = $xeGantt.computeScaleStep;
-            const { showNowLine } = taskViewOpts;
-            return h('div', {
-                ref: 'refElem',
-                class: 'vxe-gantt-view--header-wrapper'
-            }, [
-                h('div', {
-                    ref: 'refHeaderScroll',
-                    class: 'vxe-gantt-view--header-inner-wrapper',
-                    on: {
-                        scroll: $xeGanttView.triggerHeaderScrollEvent
+    $xeGanttView: {
+      default: null
+    }
+  },
+  computed: {
+    ...{}
+  },
+  methods: {
+    //
+    // Render
+    //
+    renderVN(h) {
+      const _vm = this;
+      const $xeGantt = _vm.$xeGantt;
+      const $xeGanttView = _vm.$xeGanttView;
+      const reactData = $xeGanttView.reactData;
+      const internalData = $xeGanttView.internalData;
+      const { headerGroups, viewCellWidth } = reactData;
+      const { todayDateMaps, visibleColumn } = internalData;
+      const taskViewOpts = $xeGantt.computeTaskViewOpts;
+      const minScale = $xeGantt.computeMinScale;
+      const scaleStep = $xeGantt.computeScaleStep;
+      const { showNowLine } = taskViewOpts;
+      return h("div", {
+        ref: "refElem",
+        class: "vxe-gantt-view--header-wrapper"
+      }, [
+        h("div", {
+          ref: "refHeaderScroll",
+          class: "vxe-gantt-view--header-inner-wrapper",
+          on: {
+            scroll: $xeGanttView.triggerHeaderScrollEvent
+          }
+        }, [
+          h("div", {
+            ref: "refHeaderXSpace",
+            class: "vxe-body--x-space"
+          }),
+          h("table", {
+            ref: "refHeaderTable",
+            class: "vxe-gantt-view--header-table"
+          }, [
+            h("colgroup", {}, visibleColumn.map((column, cIndex) => {
+              return h("col", {
+                key: cIndex,
+                style: {
+                  width: `${viewCellWidth}px`
+                }
+              });
+            })),
+            h("thead", {}, headerGroups.map(({ scaleItem, columns }, $rowIndex) => {
+              const { type, titleFormat, titleMethod, headerCellStyle, slots } = scaleItem;
+              const titleSlot = slots ? slots.title : null;
+              const isLast = $rowIndex === headerGroups.length - 1;
+              const todayValue = isLast && showNowLine ? todayDateMaps[type] : null;
+              return h("tr", {
+                key: $rowIndex
+              }, columns.map((column, cIndex) => {
+                const { field, childCount, dateObj, startDateObj, endDateObj } = column;
+                let label = `${column.title}`;
+                if ((isLast || minScale && (minScale.type === "date" || minScale.type === "day") && (type === "date" || type === "day")) && scaleStep > 1) {
+                  label = getI18n(`vxe.gantt.stepFormat.${type}`, {
+                    start: startDateObj,
+                    end: endDateObj,
+                    eStartLabel: getI18n(`vxe.gantt.dayss.w${startDateObj.e}`),
+                    eEndLabel: getI18n(`vxe.gantt.dayss.w${endDateObj.e}`)
+                  });
+                } else {
+                  if (type === "day") {
+                    if ($rowIndex) {
+                      label = getI18n(`vxe.gantt.tSimpleFormat.${type}`, {
+                        eLabel: getI18n(`vxe.gantt.dayss.w${dateObj.e}`)
+                      });
+                    } else {
+                      label = getI18n(`vxe.gantt.tFullFormat.${type}`, {
+                        eLabel: getI18n(`vxe.gantt.dayss.w${dateObj.e}`)
+                      });
                     }
-                }, [
-                    h('div', {
-                        ref: 'refHeaderXSpace',
-                        class: 'vxe-body--x-space'
-                    }),
-                    h('table', {
-                        ref: 'refHeaderTable',
-                        class: 'vxe-gantt-view--header-table'
-                    }, [
-                        h('colgroup', {}, visibleColumn.map((column, cIndex) => {
-                            return h('col', {
-                                key: cIndex,
-                                style: {
-                                    width: `${viewCellWidth}px`
-                                }
-                            });
-                        })),
-                        h('thead', {}, headerGroups.map(({ scaleItem, columns }, $rowIndex) => {
-                            const { type, titleFormat, titleMethod, headerCellStyle, slots } = scaleItem;
-                            const titleSlot = slots ? slots.title : null;
-                            const isLast = $rowIndex === headerGroups.length - 1;
-                            const todayValue = isLast && showNowLine ? todayDateMaps[type] : null;
-                            return h('tr', {
-                                key: $rowIndex
-                            }, columns.map((column, cIndex) => {
-                                const { field, childCount, dateObj, startDateObj, endDateObj } = column;
-                                let label = `${column.title}`;
-                                if ((isLast || (minScale && (minScale.type === 'date' || minScale.type === 'day') && (type === 'date' || type === 'day'))) && scaleStep > 1) {
-                                    label = getI18n(`vxe.gantt.stepFormat.${type}`, {
-                                        start: startDateObj,
-                                        end: endDateObj,
-                                        eStartLabel: getI18n(`vxe.gantt.dayss.w${startDateObj.e}`),
-                                        eEndLabel: getI18n(`vxe.gantt.dayss.w${endDateObj.e}`)
-                                    });
-                                }
-                                else {
-                                    if (type === 'day') {
-                                        if ($rowIndex) {
-                                            label = getI18n(`vxe.gantt.tSimpleFormat.${type}`, {
-                                                eLabel: getI18n(`vxe.gantt.dayss.w${dateObj.e}`)
-                                            });
-                                        }
-                                        else {
-                                            label = getI18n(`vxe.gantt.tFullFormat.${type}`, {
-                                                eLabel: getI18n(`vxe.gantt.dayss.w${dateObj.e}`)
-                                            });
-                                        }
-                                    }
-                                    else {
-                                        if ($rowIndex) {
-                                            label = getI18n(`vxe.gantt.tSimpleFormat.${type}`, dateObj);
-                                        }
-                                        else {
-                                            label = getI18n(`vxe.gantt.tFullFormat.${type}`, dateObj);
-                                        }
-                                    }
-                                }
-                                let cellVNs = label;
-                                const ctParams = {
-                                    source: sourceType,
-                                    type: viewType,
-                                    column,
-                                    scaleObj: scaleItem,
-                                    title: label,
-                                    dateObj,
-                                    startDateObj,
-                                    endDateObj,
-                                    $rowIndex
-                                };
-                                if (titleSlot) {
-                                    cellVNs = $xeGantt.callSlot(titleSlot, ctParams, h);
-                                }
-                                else if (titleMethod) {
-                                    cellVNs = `${titleMethod(ctParams)}`;
-                                }
-                                else if (titleFormat) {
-                                    cellVNs = XEUtils.toDateString(dateObj.date, titleFormat);
-                                }
-                                let cellStys = {};
-                                if (headerCellStyle) {
-                                    if (XEUtils.isFunction(headerCellStyle)) {
-                                        cellStys = headerCellStyle(ctParams) || null;
-                                    }
-                                    else {
-                                        cellStys = headerCellStyle;
-                                    }
-                                }
-                                return h('th', {
-                                    key: cIndex,
-                                    class: ['vxe-gantt-view--header-column', {
-                                            'is--now': showNowLine && todayValue && todayValue === field
-                                        }],
-                                    attrs: {
-                                        colspan: childCount || null,
-                                        title: titleSlot ? null : label
-                                    },
-                                    style: cellStys || undefined,
-                                    on: {
-                                        contextmenu(evnt) {
-                                            $xeGantt.handleTaskHeaderContextmenuEvent(evnt, ctParams);
-                                        }
-                                    }
-                                }, cellVNs);
-                            }));
-                        }))
-                    ])
-                ])
-            ]);
-        }
-    },
-    mounted() {
-        const _vm = this;
-        const $xeGanttView = _vm.$xeGanttView;
-        const { internalData } = $xeGanttView;
-        const { elemStore } = internalData;
-        const prefix = 'main-header-';
-        elemStore[`${prefix}wrapper`] = _vm.$refs.refElem;
-        elemStore[`${prefix}scroll`] = _vm.$refs.refHeaderScroll;
-        elemStore[`${prefix}table`] = _vm.$refs.refHeaderTable;
-        elemStore[`${prefix}xSpace`] = _vm.$refs.refHeaderXSpace;
-    },
-    destroyed() {
-        const _vm = this;
-        const $xeGanttView = _vm.$xeGanttView;
-        const { internalData } = $xeGanttView;
-        const { elemStore } = internalData;
-        const prefix = 'main-header-';
-        elemStore[`${prefix}wrapper`] = null;
-        elemStore[`${prefix}scroll`] = null;
-        elemStore[`${prefix}table`] = null;
-        elemStore[`${prefix}xSpace`] = null;
-    },
-    render(h) {
-        return this.renderVN(h);
+                  } else {
+                    if ($rowIndex) {
+                      label = getI18n(`vxe.gantt.tSimpleFormat.${type}`, dateObj);
+                    } else {
+                      label = getI18n(`vxe.gantt.tFullFormat.${type}`, dateObj);
+                    }
+                  }
+                }
+                let cellVNs = label;
+                const ctParams = {
+                  source: sourceType,
+                  type: viewType,
+                  column,
+                  scaleObj: scaleItem,
+                  title: label,
+                  dateObj,
+                  startDateObj,
+                  endDateObj,
+                  $rowIndex
+                };
+                if (titleSlot) {
+                  cellVNs = $xeGantt.callSlot(titleSlot, ctParams, h);
+                } else if (titleMethod) {
+                  cellVNs = `${titleMethod(ctParams)}`;
+                } else if (titleFormat) {
+                  cellVNs = XEUtils.toDateString(dateObj.date, titleFormat);
+                }
+                let cellStys = {};
+                if (headerCellStyle) {
+                  if (XEUtils.isFunction(headerCellStyle)) {
+                    cellStys = headerCellStyle(ctParams) || null;
+                  } else {
+                    cellStys = headerCellStyle;
+                  }
+                }
+                return h("th", {
+                  key: cIndex,
+                  class: ["vxe-gantt-view--header-column", {
+                    "is--now": showNowLine && todayValue && todayValue === field
+                  }],
+                  attrs: {
+                    colspan: childCount || null,
+                    title: titleSlot ? null : label
+                  },
+                  style: cellStys || void 0,
+                  on: {
+                    contextmenu(evnt) {
+                      $xeGantt.handleTaskHeaderContextmenuEvent(evnt, ctParams);
+                    }
+                  }
+                }, cellVNs);
+              }));
+            }))
+          ])
+        ])
+      ]);
     }
+  },
+  mounted() {
+    const _vm = this;
+    const $xeGanttView = _vm.$xeGanttView;
+    const { internalData } = $xeGanttView;
+    const { elemStore } = internalData;
+    const prefix = "main-header-";
+    elemStore[`${prefix}wrapper`] = _vm.$refs.refElem;
+    elemStore[`${prefix}scroll`] = _vm.$refs.refHeaderScroll;
+    elemStore[`${prefix}table`] = _vm.$refs.refHeaderTable;
+    elemStore[`${prefix}xSpace`] = _vm.$refs.refHeaderXSpace;
+  },
+  destroyed() {
+    const _vm = this;
+    const $xeGanttView = _vm.$xeGanttView;
+    const { internalData } = $xeGanttView;
+    const { elemStore } = internalData;
+    const prefix = "main-header-";
+    elemStore[`${prefix}wrapper`] = null;
+    elemStore[`${prefix}scroll`] = null;
+    elemStore[`${prefix}table`] = null;
+    elemStore[`${prefix}xSpace`] = null;
+  },
+  render(h) {
+    return this.renderVN(h);
+  }
 });
+export {
+  gantt_header_default as default
+};

package/es/gantt/src/gantt-view.d.ts

@@ -0,0 +1,76 @@
+import { VNode, CreateElement } from 'vue';
+import type { VxeTableConstructor, VxeTableMethods, VxeTablePrivateMethods, VxeTablePropTypes } from 'vxe-table';
+import type { VxeScrollbarProps } from 'vxe-pc-ui';
+import type { VxeGanttViewConstructor, GanttViewReactData, VxeGanttPropTypes, VxeGanttViewPrivateMethods, GanttViewInternalData, VxeGanttPrivateMethods } from '../../../types';
+export declare function handleCriticalPath($xeGanttView: VxeGanttViewConstructor & VxeGanttViewPrivateMethods, data: any[], links: VxeGanttPropTypes.Links): void;
+declare const _default: import("vue/types/vue").ExtendedVue<import("vue").default, {
+    xID: string;
+    reactData: GanttViewReactData;
+    internalData: GanttViewInternalData;
+    scrollDefaultConf: VxeScrollbarProps;
+    reScrollFlag: number;
+}, {
+    getScrollViewElem(): HTMLElement | null;
+    refreshData(): Promise<void>;
+    updateViewData(force?: boolean): Promise<void>;
+    connectUpdate({ $table }: {
+        $table: VxeTableConstructor & VxeTableMethods & VxeTablePrivateMethods;
+    }): Promise<void>;
+    handleUpdateStyle(): Promise<[void, void | null]> | undefined;
+    handleLazyRecalculate(): Promise<void>;
+    handleUpdateCurrentRow(row: any): void;
+    handleUpdateHoverRow(row: any): void;
+    handleSyncScrollTop(params: {
+        scrollTop: number;
+    }): void;
+    handleScrollEvent(evnt: Event, isRollY: boolean, isRollX: boolean, scrollTop: number, scrollLeft: number): void;
+    triggerHeaderScrollEvent(evnt: Event): void;
+    triggerBodyScrollEvent(evnt: Event): void;
+    triggerVirtualScrollXEvent(evnt: Event): void;
+    triggerVirtualScrollYEvent(evnt: Event): void;
+    handleUpdateSXSpace(): Promise<void>;
+    handleUpdateSYSpace(): Promise<void>;
+    handleUpdateSYStatus(sYLoad: boolean): void;
+    /**
+     * @private
+     */
+    updateScrollbar(): Promise<void>;
+    handleGlobalResizeEvent(): void;
+    bindScrollbarResize(): void;
+    renderScrollX(h: CreateElement): VNode;
+    renderScrollY(h: CreateElement): VNode;
+    renderViewport(h: CreateElement): VNode;
+    renderNativeBody(h: CreateElement): VNode;
+    renderVirtualBody(h: CreateElement): VNode;
+    renderVN(h: CreateElement): VNode;
+}, {
+    computeGanttIsVScrollbar: import("vxe-pc-ui").VxeComponentIsVScrollbar;
+    computeScrollbarXOpts: VxeTablePropTypes.ScrollbarXConfig;
+    computeScrollbarYOpts: VxeTablePropTypes.ScrollbarYConfig;
+    computeScrollXHeight: number;
+    computeScrollYWidth: number;
+    computeScrollXVisible: boolean | "auto" | "hidden" | "visible" | undefined;
+    computeScrollYVisible: boolean | "auto" | "hidden" | "visible" | undefined;
+    computeScrollXAutoHide: boolean | undefined;
+    computeScrollYAutoHide: boolean | undefined;
+    computeScrollbarXToTop: boolean;
+    computeScrollbarYToLeft: boolean;
+    computeScrollbarWrapperClss: string;
+    computeScaleDateList: Date[];
+    computeNowLineLeft: number;
+    computeSize: import("vxe-pc-ui").VxeComponentSizeType;
+    updateThumbSize: () => void;
+    updateThumbOffset: () => void;
+    clickTrackXEvent: (evnt: MouseEvent) => void;
+    clickTrackYEvent: (evnt: MouseEvent) => void;
+    pointerdownThumbXEvent: (evnt: PointerEvent) => void;
+    pointermoveThumbXEvent: (evnt: PointerEvent) => void;
+    cleatPointerThumbEvent: (evnt: PointerEvent) => void;
+    pointerdownThumbYEvent: (evnt: PointerEvent) => void;
+    pointermoveThumbYEvent: (evnt: PointerEvent) => void;
+    $xeGantt: import("vxe-pc-ui").VxeComponentBaseOptions & {
+        reactData: import("vxe-pc-ui/types/components/gantt").GanttReactData<any>;
+        internalData: import("vxe-pc-ui/types/components/gantt").GanttInternalData;
+    } & import("vxe-pc-ui/types/components/gantt").VxeGanttMethods<any> & import("vxe-pc-ui/types/components/gantt").VxeGanttPrivateComputed<any> & import("vxe-pc-ui/types/components/gantt").VxeGanttProps<any> & import("vue").default & VxeGanttPrivateMethods<any>;
+}, unknown>;
+export default _default;