hys-ui 0.1.0 → 0.2.0

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

@@ -1,17 +1,69 @@
-type __VLS_Props = {
-    modelValue: string;
-    disabled?: boolean;
-    min?: string;
-    max?: string;
-    placeholder?: string;
-    label?: string;
-    clearable?: boolean;
-    disabledDate?: (date: Date) => boolean;
+import { type HysDatePickerProps, type HysDatePickerValue, type HysDatePickerChange, type HysDateScalar, type HysDatePickerView, type HysDatePickerSlots } from "../../composables/datePicker";
+declare const __VLS_export: <V extends HysDatePickerValue = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<HysDatePickerProps<V> & {
+        onChange?: ((value: V, info: HysDatePickerChange) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onInvalid?: ((info: {
+            reason: string;
+            dates?: readonly (Date | null)[];
+            error?: unknown;
+        }) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:mode"?: ((value: HysDatePickerView) => any) | undefined;
+        onPanelChange?: ((date: Date, view: HysDatePickerView, context: {
+            index: number;
+        }) => any) | undefined;
+        "onValue-change"?: ((value: V, info: HysDatePickerChange) => any) | undefined;
+        "onVisible-change"?: ((value: boolean) => any) | undefined;
+        "onUpdate:panelValue"?: ((value: HysDateScalar) => any) | undefined;
+        onCalendarChange?: ((value: HysDatePickerValue, context: {
+            range: "start" | "end";
+            dates: readonly (Date | null)[];
+        }) => any) | undefined;
+        onOk?: ((value: V) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").ComputedRef<HTMLElement | undefined>;
+        open: import("vue").ComputedRef<boolean>;
+        value: import("vue").ComputedRef<V | undefined>;
+        draft: import("vue").ComputedRef<readonly (Date | null)[]>;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        show: () => Promise<boolean>;
+        hide: (restore?: boolean) => void | undefined;
+        handleOpen: () => Promise<boolean>;
+        handleClose: () => void | undefined;
+        clear: () => Promise<boolean>;
+        setValue: (value: V) => Promise<boolean>;
+        confirm: () => Promise<boolean>;
+        cancel: () => void | undefined;
+        showMonth: (value: HysDateScalar) => Promise<boolean>;
+        setMode: (view: HysDatePickerView) => boolean;
+    }>) => void;
+    attrs: any;
+    slots: HysDatePickerSlots;
+    emit: ((evt: "change", value: V, info: HysDatePickerChange) => void) & ((evt: "update:modelValue", value: V) => void) & ((evt: "clear") => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "invalid", info: {
+        reason: string;
+        dates?: readonly (Date | null)[];
+        error?: unknown;
+    }) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:mode", value: HysDatePickerView) => void) & ((evt: "panelChange", date: Date, view: HysDatePickerView, context: {
+        index: number;
+    }) => void) & ((evt: "value-change", value: V, info: HysDatePickerChange) => void) & ((evt: "visible-change", value: boolean) => void) & ((evt: "update:panelValue", value: HysDateScalar) => void) & ((evt: "calendarChange", value: HysDatePickerValue, context: {
+        range: "start" | "end";
+        dates: readonly (Date | null)[];
+    }) => void) & ((evt: "ok", value: V) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/HysDatePicker/HysDatePickerControl.vue.d.ts

@@ -0,0 +1,90 @@
+import { type HysDatePickerProps, type HysDatePickerValue, type HysDatePickerSlots, type HysDatePickerView } from "../../composables/datePicker";
+type __VLS_Props = HysDatePickerProps & {
+    range?: boolean;
+};
+type __VLS_Slots = HysDatePickerSlots;
+declare function focusTrigger(): void;
+declare function hide(restore?: boolean): void;
+declare function cancel(): void;
+declare function clear(): Promise<boolean>;
+declare function confirm(): Promise<boolean>;
+declare function showMonth(value: unknown): Promise<boolean>;
+declare function setValue(value: HysDatePickerValue): Promise<boolean>;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    open: import("vue").ComputedRef<boolean>;
+    value: import("vue").ComputedRef<HysDatePickerValue>;
+    draft: import("vue").ComputedRef<(Date | null)[]>;
+    focus: typeof focusTrigger;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: typeof hide;
+    handleOpen: () => Promise<boolean>;
+    handleClose: typeof hide;
+    clear: typeof clear;
+    setValue: typeof setValue;
+    confirm: typeof confirm;
+    cancel: typeof cancel;
+    showMonth: typeof showMonth;
+    setMode: (mode: HysDatePickerView) => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+    clear: (...args: any[]) => void;
+    blur: (...args: any[]) => void;
+    focus: (...args: any[]) => void;
+    invalid: (...args: any[]) => void;
+    "update:open": (...args: any[]) => void;
+    "update:mode": (...args: any[]) => void;
+    panelChange: (...args: any[]) => void;
+    "value-change": (...args: any[]) => void;
+    "visible-change": (...args: any[]) => void;
+    "update:panelValue": (...args: any[]) => void;
+    calendarChange: (...args: any[]) => void;
+    ok: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onClear?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onInvalid?: ((...args: any[]) => any) | undefined;
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:mode"?: ((...args: any[]) => any) | undefined;
+    onPanelChange?: ((...args: any[]) => any) | undefined;
+    "onValue-change"?: ((...args: any[]) => any) | undefined;
+    "onVisible-change"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:panelValue"?: ((...args: any[]) => any) | undefined;
+    onCalendarChange?: ((...args: any[]) => any) | undefined;
+    onOk?: ((...args: any[]) => any) | undefined;
+}>, {
+    bordered: boolean;
+    type: import("../../index.js").HysDatePickerType;
+    clearable: boolean;
+    open: boolean;
+    appendTo: string | false | HTMLElement;
+    showToday: boolean;
+    firstDayOfWeek: number;
+    locale: string;
+    showAdjacentDays: boolean;
+    showFooter: boolean;
+    validateEvent: boolean;
+    editable: boolean;
+    showNow: boolean;
+    showConfirm: boolean;
+    hourStep: number;
+    minuteStep: number;
+    secondStep: number;
+    showSeconds: boolean;
+    rangeSeparator: string;
+    singlePanel: boolean;
+    rangeValidation: "endpoints" | "continuous";
+}, {}, {}, {}, 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/components/HysDatePicker/HysDatePickerPanel.vue.d.ts

@@ -0,0 +1,93 @@
+import { type HysDatePoint, type HysDatePickerCell, type HysDatePickerView, type HysDatePickerUnit, type HysDatePickerLocale, type HysDatePickerWeek } from "../../composables/datePicker";
+type __VLS_Props = {
+    month: number;
+    view: HysDatePickerView;
+    unit: HysDatePickerUnit;
+    selected: readonly (HysDatePoint | null)[];
+    range: boolean;
+    preview?: number;
+    first: number;
+    weekContains: number;
+    weekNumberFormatter?: (week: HysDatePickerWeek) => string;
+    locale: string;
+    words: HysDatePickerLocale;
+    weekNumbers: boolean;
+    adjacent: boolean;
+    disabled: boolean;
+    available: (day: number) => boolean;
+    periodAvailable: (start: number, end: number) => boolean;
+    cellClassName?: (cell: HysDatePickerCell) => string;
+};
+declare function focus(day?: number): Promise<void>;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        'prev-year'?: (props: {}) => any;
+    } & {
+        'prev-month'?: (props: {}) => any;
+    } & {
+        'next-month'?: (props: {}) => any;
+    } & {
+        'next-year'?: (props: {}) => any;
+    } & {
+        'week-number'?: (props: {
+            selected: boolean;
+            disabled: boolean;
+            year: number;
+            week: number;
+            start: string;
+            end: string;
+            dates: readonly string[];
+        }) => any;
+    } & {
+        'week-number'?: (props: {
+            selected: boolean;
+            disabled: boolean;
+            year: number;
+            week: number;
+            start: string;
+            end: string;
+            dates: readonly string[];
+        }) => any;
+    } & {
+        cell?: (props: {
+            date: Date;
+            iso: string;
+            value: number;
+            end: number;
+            text: string;
+            type: HysDatePickerView;
+            outside: boolean;
+            disabled: boolean;
+            selected: boolean;
+            inRange: boolean;
+            today: boolean;
+            week: number;
+            weekYear: number;
+            weekStart: string;
+            weekEnd: string;
+        }) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    focus: typeof focus;
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    mode: (view: HysDatePickerView) => any;
+    preview: (day: number | undefined) => any;
+    browse: (day: number) => any;
+    pick: (day: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMode?: ((view: HysDatePickerView) => any) | undefined;
+    onPreview?: ((day: number | undefined) => any) | undefined;
+    onBrowse?: ((day: number) => any) | undefined;
+    onPick?: ((day: number) => any) | undefined;
+}>, {}, {}, {}, {}, 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/components/HysDateRangePicker/HysDateRangePicker.vue.d.ts

@@ -1,17 +1,69 @@
-type __VLS_Props = {
-    modelValue: [string, string];
-    disabled?: boolean;
-    min?: string;
-    max?: string;
-    placeholder?: string;
-    label?: string;
-    clearable?: boolean;
-    disabledDate?: (date: Date) => boolean;
+import { type HysDateRangePickerProps, type HysDatePickerValue, type HysDatePickerChange, type HysDateScalar, type HysDatePickerView, type HysDatePickerSlots } from "../../composables/datePicker";
+declare const __VLS_export: <V extends HysDatePickerValue = [string, string]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<HysDateRangePickerProps<V> & {
+        onChange?: ((value: V, info: HysDatePickerChange) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onInvalid?: ((info: {
+            reason: string;
+            dates?: readonly (Date | null)[];
+            error?: unknown;
+        }) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:mode"?: ((value: HysDatePickerView) => any) | undefined;
+        onPanelChange?: ((date: Date, view: HysDatePickerView, context: {
+            index: number;
+        }) => any) | undefined;
+        "onValue-change"?: ((value: V, info: HysDatePickerChange) => any) | undefined;
+        "onVisible-change"?: ((value: boolean) => any) | undefined;
+        "onUpdate:panelValue"?: ((value: HysDateScalar) => any) | undefined;
+        onCalendarChange?: ((value: HysDatePickerValue, context: {
+            range: "start" | "end";
+            dates: readonly (Date | null)[];
+        }) => any) | undefined;
+        onOk?: ((value: V) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").ComputedRef<HTMLElement | undefined>;
+        open: import("vue").ComputedRef<boolean>;
+        value: import("vue").ComputedRef<V | undefined>;
+        draft: import("vue").ComputedRef<readonly (Date | null)[]>;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        show: () => Promise<boolean>;
+        hide: (restore?: boolean) => void | undefined;
+        handleOpen: () => Promise<boolean>;
+        handleClose: () => void | undefined;
+        clear: () => Promise<boolean>;
+        setValue: (value: V) => Promise<boolean>;
+        confirm: () => Promise<boolean>;
+        cancel: () => void | undefined;
+        showMonth: (value: HysDateScalar) => Promise<boolean>;
+        setMode: (view: HysDatePickerView) => boolean;
+    }>) => void;
+    attrs: any;
+    slots: HysDatePickerSlots;
+    emit: ((evt: "change", value: V, info: HysDatePickerChange) => void) & ((evt: "update:modelValue", value: V) => void) & ((evt: "clear") => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "invalid", info: {
+        reason: string;
+        dates?: readonly (Date | null)[];
+        error?: unknown;
+    }) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:mode", value: HysDatePickerView) => void) & ((evt: "panelChange", date: Date, view: HysDatePickerView, context: {
+        index: number;
+    }) => void) & ((evt: "value-change", value: V, info: HysDatePickerChange) => void) & ((evt: "visible-change", value: boolean) => void) & ((evt: "update:panelValue", value: HysDateScalar) => void) & ((evt: "calendarChange", value: HysDatePickerValue, context: {
+        range: "start" | "end";
+        dates: readonly (Date | null)[];
+    }) => void) & ((evt: "ok", value: V) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: [string, string]) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: [string, string]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -1,8 +1,12 @@
 type __VLS_Props = {
     label?: string;
-    direction?: 'horizontal' | 'vertical';
+    direction?: "horizontal" | "vertical";
     dashed?: boolean;
-    orientation?: 'left' | 'center' | 'right';
+    orientation?: "left" | "center" | "right" | "start" | "end";
+    borderStyle?: "solid" | "dashed" | "dotted" | "double" | "none";
+    orientationMargin?: number | string;
+    plain?: boolean;
+    size?: "sm" | "md" | "lg";
 };
 declare const __VLS_template: () => {
     __VLS_Slots: {
@@ -11,8 +15,9 @@ declare const __VLS_template: () => {
 };
 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<{}>, {
+    size: "sm" | "md" | "lg";
     direction: "horizontal" | "vertical";
-    orientation: "center" | "left" | "right";
+    orientation: "left" | "right" | "center" | "end" | "start";
 }, {}, {}, {}, 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/HysDrawer/HysDrawer.vue.d.ts

@@ -2,6 +2,7 @@ type __VLS_Props = {
     open: boolean;
     title: string;
     width?: string;
+    height?: string;
     closeOnMask?: boolean;
     closeOnEscape?: boolean;
     showClose?: boolean;

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

@@ -4,19 +4,23 @@ export interface ManagedFile {
     size: number;
     url?: string;
 }
+type __VLS_Props = {
+    disabled?: boolean;
+};
 type __VLS_ModelProps = {
     modelValue?: ManagedFile[];
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: ManagedFile[]) => any;
+    download: (id: string) => any;
     remove: (id: string) => any;
     upload: (files: File[]) => any;
-    download: (id: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: ManagedFile[]) => any) | undefined;
+    onDownload?: ((id: string) => any) | undefined;
     onRemove?: ((id: string) => any) | undefined;
     onUpload?: ((files: File[]) => any) | undefined;
-    onDownload?: ((id: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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;