hys-ui 0.1.1 → 0.3.0

package/dist/types/components/HysDrawer/HysDrawer.vue.d.ts

@@ -1,46 +1,103 @@
-type __VLS_Props = {
-    open: boolean;
-    title: string;
-    width?: string;
-    height?: string;
-    closeOnMask?: boolean;
-    closeOnEscape?: boolean;
-    showClose?: boolean;
-    destroyOnClose?: boolean;
-    fullscreen?: boolean;
-    placement?: 'left' | 'right' | 'top' | 'bottom';
-    beforeClose?: (reason: 'mask' | 'escape' | 'button') => boolean | void | Promise<boolean | void>;
-};
-declare function requestClose(reason?: 'mask' | 'escape' | 'button'): Promise<void>;
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        header?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    } & {
-        footer?: (props: {
-            close: typeof requestClose;
-            closing: boolean;
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    close: typeof requestClose;
+import { type HysDrawerProps, type HysDrawerSlots, type HysDrawerResizeInfo } from "../../composables/drawer";
+type __VLS_Slots = HysDrawerSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysDrawerProps, {
     element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    body: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    open: import("vue").Ref<boolean, boolean>;
+    closing: import("vue").ComputedRef<boolean>;
+    confirming: import("vue").ComputedRef<boolean>;
+    fullscreen: import("vue").ComputedRef<boolean>;
+    resizing: import("vue").Ref<boolean, boolean>;
+    size: import("vue").ComputedRef<number>;
+    pushed: import("vue").ComputedRef<boolean>;
+    focus: () => void;
+    show: () => Promise<boolean>;
+    close: (reasonOrEvent?: import("../../index.js").HysModalCloseReason | Event, event?: Event) => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    confirm: (event?: Event) => Promise<boolean>;
+    setFullscreen: (value: boolean) => Promise<boolean>;
+    toggleFullscreen: () => Promise<boolean>;
+    resizeTo: (value: number | string) => Promise<boolean>;
+    resetSize: () => Promise<boolean>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
     close: () => any;
-    closeError: (error: unknown) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    closeError: (error: unknown, context: import("../../index.js").HysModalActionContext) => any;
+    afterClose: () => any;
+    visibleChange: (value: boolean) => any;
+    cancel: (context: import("../../index.js").HysModalActionContext) => any;
+    resize: (size: number) => any;
+    open: () => any;
+    "update:open": (value: boolean) => any;
+    opened: () => any;
+    closed: () => any;
+    ok: (context: import("../../index.js").HysModalActionContext) => any;
+    resizeEnd: (size: number, info: HysDrawerResizeInfo) => any;
+    resizeStart: (size: number) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+    confirmError: (error: unknown, context: import("../../index.js").HysModalActionContext) => any;
+    "update:fullscreen": (value: boolean) => any;
+    fullscreenChange: (value: boolean) => any;
+    "update:resizeValue": (value: number | null) => any;
+    afterOpenChange: (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<HysDrawerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     onClose?: (() => any) | undefined;
-    onCloseError?: ((error: unknown) => any) | undefined;
+    onCloseError?: ((error: unknown, context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onAfterClose?: (() => any) | undefined;
+    onVisibleChange?: ((value: boolean) => any) | undefined;
+    onCancel?: ((context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onResize?: ((size: number) => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOk?: ((context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onResizeEnd?: ((size: number, info: HysDrawerResizeInfo) => any) | undefined;
+    onResizeStart?: ((size: number) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onConfirmError?: ((error: unknown, context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    "onUpdate:fullscreen"?: ((value: boolean) => any) | undefined;
+    onFullscreenChange?: ((value: boolean) => any) | undefined;
+    "onUpdate:resizeValue"?: ((value: number | null) => any) | undefined;
+    onAfterOpenChange?: ((value: boolean) => any) | undefined;
 }>, {
-    width: string;
-    placement: "left" | "right" | "top" | "bottom";
-    closeOnMask: boolean;
+    modelValue: boolean;
+    size: number | (string & {}) | import("../../index.js").HysDrawerSizeName;
+    footer: boolean;
+    title: string;
+    autofocus: boolean;
+    transition: false | "fade" | "slide" | "none" | "slide-fade";
+    closeText: string;
+    transitionDuration: number;
+    placement: import("../../index.js").HysDrawerPlacement;
+    open: boolean;
+    appendTo: string | false | HTMLElement;
+    loadingText: string;
+    fullscreen: boolean;
     closeOnEscape: boolean;
+    cancelText: string;
+    closeOnMask: boolean;
     showClose: boolean;
     destroyOnClose: boolean;
+    modal: boolean;
+    lockScroll: boolean;
+    trapFocus: boolean;
+    restoreFocus: boolean;
+    headerSize: import("../../index.js").HysModalSectionSize;
+    footerSize: import("../../index.js").HysModalSectionSize;
+    headerAriaLevel: number;
+    fullscreenText: string;
+    restoreText: string;
+    showCancel: boolean;
+    okText: string;
+    showError: boolean;
+    closeOnConfirm: boolean;
+    withHeader: boolean;
+    resetSizeOnClose: 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/components/HysEmpty/HysEmpty.vue.d.ts

@@ -1,23 +1,27 @@
-type __VLS_Props = {
-    title?: string;
-    description?: string;
-    image?: string;
-    imageSize?: number;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        image?: (props: {}) => any;
-    } & {
-        description?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    title: string;
-    description: string;
-    imageSize: number;
+import { type HysEmptyProps, type HysEmptySlots } from "../../composables/feedback";
+type __VLS_Slots = HysEmptySlots;
+declare function retryImage(): boolean;
+declare const __VLS_base: import("vue").DefineComponent<HysEmptyProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    imageElement: import("vue").Ref<HTMLImageElement | undefined, HTMLImageElement | undefined>;
+    loadingImage: import("vue").Ref<boolean, boolean>;
+    failedImage: import("vue").Ref<boolean, boolean>;
+    retryImage: typeof retryImage;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    imageLoad: (event: Event) => any;
+    imageError: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<HysEmptyProps> & Readonly<{
+    onImageLoad?: ((event: Event) => any) | undefined;
+    onImageError?: ((event: Event) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    title: string | false;
+    image: string | false;
+    description: string | false;
+    imageFit: "fill" | "none" | "contain" | "cover" | "scale-down";
+    imageLoading: "lazy" | "eager";
+    illustration: import("../..").HysEmptyIllustration;
+    showImageLoading: 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/components/HysForm/HysForm.vue.d.ts

@@ -1,48 +1,140 @@
-import { type HysFormRule } from '../../composables/formContext';
+import { type HysFormField, type HysFormFieldData, type HysFormFieldState, type HysFormMessages, type HysFormPath, type HysFormPaths, type HysFormRules, type HysFormTrigger, type HysFormValidateCallback, type HysFormValidationResult } from "../../composables/formContext";
+import { type HysFormCol, type HysFormGridValue } from "../../composables/formLayout";
 type __VLS_Props = {
     model?: Record<string, unknown>;
-    rules?: Record<string, HysFormRule | HysFormRule[]>;
-    validate?: () => boolean | Promise<boolean>;
+    rules?: HysFormRules;
+    validate?: (context: {
+        signal: AbortSignal;
+    }) => boolean | Promise<boolean>;
+    validateMessages?: HysFormMessages;
+    validateOnRuleChange?: boolean;
+    validateTrigger?: HysFormTrigger | HysFormTrigger[];
+    initialValues?: Record<string, unknown>;
     loading?: boolean;
     disabled?: boolean;
     inline?: boolean;
-    labelPosition?: 'top' | 'left' | 'right';
-    labelWidth?: string;
+    layout?: "horizontal" | "vertical" | "inline";
+    columns?: HysFormGridValue;
+    gap?: number | string;
+    size?: "sm" | "md" | "lg";
+    labelPosition?: "top" | "left" | "right";
+    labelWidth?: string | number;
+    labelAlign?: "left" | "right";
+    labelWrap?: boolean;
+    labelSuffix?: string;
+    colon?: boolean;
+    labelCol?: HysFormCol;
+    wrapperCol?: HysFormCol;
+    showLabel?: boolean;
+    showFeedback?: boolean;
+    showRequiredMark?: boolean;
+    requiredMarkPosition?: "left" | "right";
+    optionalMark?: string;
+    inlineFeedback?: boolean;
+    feedbackIcon?: boolean;
+    validateFirst?: boolean;
+    preserve?: boolean;
+    scrollToError?: boolean | ScrollIntoViewOptions;
+    focusOnError?: boolean;
 };
-declare function validateField(name: string, trigger?: 'blur' | 'change'): Promise<boolean>;
-declare function clearValidate(names?: string | string[]): void;
-declare function validate(): Promise<boolean>;
-declare function resetFields(): void;
+declare function clearValidate(paths?: HysFormPaths): void;
+declare function validateField(path: HysFormPath, triggerOrCallback?: HysFormTrigger | HysFormValidateCallback): Promise<boolean>;
+declare function validateResult(paths?: HysFormPaths): Promise<HysFormValidationResult>;
+declare function validate(pathsOrCallback?: HysFormPaths | HysFormValidateCallback, callback?: HysFormValidateCallback): Promise<boolean>;
+declare function getFieldValue(path: HysFormPath): unknown;
+declare function getFieldsValue(paths?: HysFormPaths): Record<string, unknown>;
+declare function setFieldsValue(values: Record<string, unknown>): void;
+declare function setFieldValue(path: HysFormPath, value: unknown): void;
+declare function getFieldError(path: HysFormPath): string[];
+declare function getFieldsError(paths?: HysFormPaths): {
+    name: string;
+    errors: string[];
+    warnings: string[];
+}[];
+declare function setFields(fields: readonly HysFormFieldData[]): void;
+declare function setInitialValues(values: Record<string, unknown>): void;
+declare function resetFields(paths?: HysFormPaths): void;
+declare function captureInitialValues(paths?: HysFormPaths): void;
+declare function scrollToField(path: HysFormPath, options?: ScrollIntoViewOptions): void;
+declare function focusField(path: HysFormPath): void;
+declare function submit(): Promise<HysFormValidationResult | undefined>;
 declare const __VLS_template: () => {
     __VLS_Slots: {
-        default?: (props: {}) => any;
+        default?: (props: {
+            errors: Record<string, string>;
+            warnings: Record<string, string>;
+            validating: boolean;
+        }) => any;
     } & {
         actions?: (props: {
             validating: boolean;
             reset: typeof resetFields;
+            errors: Record<string, string>;
+            warnings: Record<string, string>;
         }) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     validate: typeof validate;
+    validateFields: typeof validate;
+    validateResult: typeof validateResult;
     validateField: typeof validateField;
     clearValidate: typeof clearValidate;
     resetFields: typeof resetFields;
+    captureInitialValues: typeof captureInitialValues;
+    setInitialValues: typeof setInitialValues;
+    scrollToField: typeof scrollToField;
+    focusField: typeof focusField;
+    getField: (path: HysFormPath) => HysFormField | undefined;
+    getFields: () => HysFormField[];
+    fields: import("vue").ShallowRef<HysFormField[], HysFormField[]>;
+    getFieldValue: typeof getFieldValue;
+    getFieldsValue: typeof getFieldsValue;
+    setFieldValue: typeof setFieldValue;
+    setFieldsValue: typeof setFieldsValue;
+    getFieldError: typeof getFieldError;
+    getFieldsError: typeof getFieldsError;
+    setFields: typeof setFields;
+    submit: typeof submit;
     errors: import("vue").Ref<Record<string, string>, Record<string, string>>;
+    warnings: import("vue").Ref<Record<string, string>, Record<string, string>>;
+    errorMessages: import("vue").Ref<Record<string, string[]>, Record<string, string[]>>;
+    warningMessages: import("vue").Ref<Record<string, string[]>, Record<string, string[]>>;
+    states: import("vue").Ref<Record<string, HysFormFieldState>, Record<string, HysFormFieldState>>;
     validating: import("vue").Ref<boolean, boolean>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    submit: () => any;
-    reset: () => any;
-    invalid: () => any;
+    submit: (values: Record<string, unknown>) => any;
+    reset: (names: string[]) => any;
+    invalid: (result: HysFormValidationResult) => any;
+    validate: (name: string, valid: boolean, message: string) => any;
+    validation: (result: HysFormValidationResult) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSubmit?: (() => any) | undefined;
-    onReset?: (() => any) | undefined;
-    onInvalid?: (() => any) | undefined;
+    onSubmit?: ((values: Record<string, unknown>) => any) | undefined;
+    onReset?: ((names: string[]) => any) | undefined;
+    onInvalid?: ((result: HysFormValidationResult) => any) | undefined;
+    onValidate?: ((name: string, valid: boolean, message: string) => any) | undefined;
+    onValidation?: ((result: HysFormValidationResult) => any) | undefined;
 }>, {
-    rules: Record<string, HysFormRule | HysFormRule[]>;
+    size: "sm" | "md" | "lg";
+    preserve: boolean;
+    columns: HysFormGridValue;
+    gap: string | number;
+    rules: HysFormRules;
+    validateOnRuleChange: boolean;
+    validateTrigger: HysFormTrigger | HysFormTrigger[];
     labelPosition: "left" | "right" | "top";
-    labelWidth: string;
+    labelWidth: string | number;
+    labelWrap: boolean;
+    labelSuffix: string;
+    showLabel: boolean;
+    showFeedback: boolean;
+    showRequiredMark: boolean;
+    requiredMarkPosition: "left" | "right";
+    optionalMark: string;
+    validateFirst: boolean;
+    scrollToError: boolean | ScrollIntoViewOptions;
+    focusOnError: 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/components/HysFormItem/HysFormItem.vue.d.ts

@@ -1,22 +1,128 @@
+import { type HysFormCol, type HysFormGridValue } from "../../composables/formLayout";
+import { type HysFormPath, type HysFormRule, type HysFormStatus, type HysFormTrigger } from "../../composables/formContext";
 type __VLS_Props = {
     label?: string;
-    prop?: string;
+    prop?: HysFormPath;
+    rules?: HysFormRule | HysFormRule[];
+    dependencies?: HysFormPath[];
     error?: string;
+    warning?: string;
+    status?: HysFormStatus;
     required?: boolean;
+    showRequiredMark?: boolean;
+    requiredMarkPosition?: "left" | "right";
     hint?: string;
     for?: string;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    labelPosition?: "top" | "left" | "right";
+    labelWidth?: string | number;
+    labelAlign?: "left" | "right";
+    labelWrap?: boolean;
+    labelSuffix?: string;
+    colon?: boolean;
+    labelCol?: HysFormCol;
+    wrapperCol?: HysFormCol;
+    span?: HysFormGridValue;
+    optionalMark?: string;
+    tooltip?: string;
+    help?: string;
+    extra?: string;
+    showLabel?: boolean;
+    showFeedback?: boolean;
+    feedbackIcon?: boolean;
+    inlineFeedback?: boolean;
+    validateFirst?: boolean;
+    preserve?: boolean;
+    autoLink?: boolean;
+    group?: boolean;
+    noStyle?: boolean;
+    validateTrigger?: HysFormTrigger | HysFormTrigger[];
 };
+declare function validate(event?: HysFormTrigger): Promise<boolean>;
+declare function focus(): void;
 declare const __VLS_template: () => {
     __VLS_Slots: {
+        label?: (props: {
+            required: boolean;
+            status: HysFormStatus;
+        }) => any;
+    } & {
+        tooltip?: (props: {}) => any;
+    } & {
         default?: (props: {
             id: string;
             invalid: boolean;
             error: string | undefined;
+            warning: string | undefined;
+            errors: string[];
+            warnings: string[];
+            status: HysFormStatus;
+            disabled: boolean;
+            size: "sm" | "md" | "lg";
+        }) => any;
+    } & {
+        help?: (props: {
+            error: string | undefined;
+            warning: string | undefined;
+            errors: string[];
+            warnings: string[];
+            status: HysFormStatus;
+        }) => any;
+    } & {
+        feedback?: (props: {
+            error: string | undefined;
+            warning: string | undefined;
+            errors: string[];
+            warnings: string[];
+            status: HysFormStatus;
+        }) => any;
+    } & {
+        error?: (props: {
+            error: string;
+            errors: string[];
+        }) => any;
+    } & {
+        warning?: (props: {
+            warning: string;
+            warnings: string[];
+        }) => any;
+    } & {
+        hint?: (props: {}) => any;
+    } & {
+        extra?: (props: {
+            status: HysFormStatus;
         }) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    validate: typeof validate;
+    clearValidate: () => void;
+    resetField: () => void;
+    setInitialValue: ((value: unknown) => void) | undefined;
+    focus: typeof focus;
+    path: import("vue").ComputedRef<string>;
+    status: import("vue").ComputedRef<HysFormStatus>;
+    error: import("vue").ComputedRef<string | undefined>;
+    warning: import("vue").ComputedRef<string | undefined>;
+    size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+    validateMessage: import("vue").ComputedRef<string | undefined>;
+    validateState: import("vue").ComputedRef<HysFormStatus>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    required: boolean;
+    preserve: boolean;
+    group: boolean;
+    labelWrap: boolean;
+    colon: boolean;
+    showLabel: boolean;
+    showFeedback: boolean;
+    showRequiredMark: boolean;
+    inlineFeedback: boolean;
+    feedbackIcon: boolean;
+    validateFirst: boolean;
+    autoLink: 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;

package/dist/types/components/HysGantt/HysGantt.vue.d.ts

@@ -1,3 +1,5 @@
+import type { HysPopupMotionProps } from '../../motion/popup';
+import type { HysGanttScrollOptions, HysGanttDependencyChange, HysGanttDependencyInvalid, HysGanttDependencyMove, HysGanttHistoryEntry, HysGanttHistoryState, HysGanttHistoryInvalid, HysGanttConflict } from "../../composables/gantt";
 export interface GanttItem {
     id: string | number;
     title: string;
@@ -10,36 +12,113 @@ export interface GanttItem {
     color?: string;
     disabled?: boolean;
 }
-type Scale = 'day' | 'week' | 'month';
-type __VLS_Props = {
+type Scale = "day" | "week" | "month";
+type __VLS_Props = HysPopupMotionProps & {
     items: GanttItem[];
     modelValue?: string | number | null;
     scale?: Scale;
     editable?: boolean;
     rowHeight?: number;
     labelWidth?: number;
+    labelResizable?: boolean;
+    minLabelWidth?: number;
+    maxLabelWidth?: number;
     fitContainer?: boolean;
+    height?: number | string;
+    maxHeight?: number | string | false;
+    virtual?: boolean;
+    overscan?: number;
+    dependencyEditable?: boolean;
+    showDependencies?: boolean;
+    history?: boolean;
+    historyLimit?: number;
+    historyKeyboard?: boolean;
+    showHistoryControls?: boolean;
+    showConflicts?: boolean;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (id: string | number | null) => any;
+declare function scrollToTask(id: string | number, options?: HysGanttScrollOptions): Promise<boolean>;
+declare function scrollToTop(options?: Pick<HysGanttScrollOptions, "behavior">): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    viewport: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    scrollToTask: typeof scrollToTask;
+    scrollToTop: typeof scrollToTop;
+    addDependency: (sourceId: string | number, targetId: string | number) => Promise<boolean>;
+    removeDependency: (sourceId: string | number, targetId: string | number) => Promise<boolean>;
+    moveDependency: (sourceId: string | number, previousTargetId: string | number, targetId: string | number) => Promise<boolean>;
+    cancelDependency: () => void;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    clearHistory: () => void;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    historyState: import("vue").ComputedRef<HysGanttHistoryState>;
+    conflicts: import("vue").ComputedRef<{
+        id: string;
+        type: import("../..").HysGanttConflictType;
+        taskId: string | number;
+        taskTitle: string;
+        sourceId?: string | number;
+        sourceTitle?: string;
+        message: string;
+        expectedStart?: string;
+        days?: number;
+    }[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (item: GanttItem) => any;
+    "update:modelValue": (id: string | number | null) => any;
     open: (item: GanttItem) => any;
+    undo: (entry: HysGanttHistoryEntry) => any;
+    redo: (entry: HysGanttHistoryEntry) => any;
     "update:scale": (value: Scale) => any;
     scaleChange: (value: Scale) => any;
     "update:items": (items: GanttItem[]) => any;
+    dependencyAdd: (info: HysGanttDependencyChange, item: GanttItem) => any;
+    dependencyRemove: (info: HysGanttDependencyChange, item: GanttItem) => any;
+    dependencyInvalid: (info: HysGanttDependencyInvalid) => any;
+    dependencyMove: (info: HysGanttDependencyMove, item: GanttItem, previousItem: GanttItem) => any;
+    "update:labelWidth": (width: number) => any;
+    labelResize: (width: number) => any;
+    historyChange: (state: HysGanttHistoryState) => any;
+    historyInvalid: (info: HysGanttHistoryInvalid) => any;
+    conflictChange: (conflicts: HysGanttConflict[]) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((id: string | number | null) => any) | undefined;
     onChange?: ((item: GanttItem) => any) | undefined;
+    "onUpdate:modelValue"?: ((id: string | number | null) => any) | undefined;
     onOpen?: ((item: GanttItem) => any) | undefined;
+    onUndo?: ((entry: HysGanttHistoryEntry) => any) | undefined;
+    onRedo?: ((entry: HysGanttHistoryEntry) => any) | undefined;
     "onUpdate:scale"?: ((value: Scale) => any) | undefined;
     onScaleChange?: ((value: Scale) => any) | undefined;
     "onUpdate:items"?: ((items: GanttItem[]) => any) | undefined;
+    onDependencyAdd?: ((info: HysGanttDependencyChange, item: GanttItem) => any) | undefined;
+    onDependencyRemove?: ((info: HysGanttDependencyChange, item: GanttItem) => any) | undefined;
+    onDependencyInvalid?: ((info: HysGanttDependencyInvalid) => any) | undefined;
+    onDependencyMove?: ((info: HysGanttDependencyMove, item: GanttItem, previousItem: GanttItem) => any) | undefined;
+    "onUpdate:labelWidth"?: ((width: number) => any) | undefined;
+    onLabelResize?: ((width: number) => any) | undefined;
+    onHistoryChange?: ((state: HysGanttHistoryState) => any) | undefined;
+    onHistoryInvalid?: ((info: HysGanttHistoryInvalid) => any) | undefined;
+    onConflictChange?: ((conflicts: HysGanttConflict[]) => any) | undefined;
 }>, {
     scale: Scale;
+    maxHeight: string | number | false;
+    virtual: boolean;
+    overscan: number;
     editable: boolean;
     labelWidth: number;
     rowHeight: number;
+    labelResizable: boolean;
+    minLabelWidth: number;
+    maxLabelWidth: number;
     fitContainer: boolean;
+    dependencyEditable: boolean;
+    showDependencies: boolean;
+    history: boolean;
+    historyLimit: number;
+    historyKeyboard: boolean;
+    showHistoryControls: boolean;
+    showConflicts: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;