vant 3.6.15 → 3.6.16

package/es/datetime-picker/TimePicker.mjs

@@ -0,0 +1,117 @@
+import { createVNode as _createVNode, mergeProps as _mergeProps } from "vue";
+import { ref, watch, computed, nextTick, onMounted, defineComponent } from "vue";
+import { pick, clamp, extend, padZero, createNamespace, makeNumericProp } from "../utils/index.mjs";
+import { times, sharedProps, pickerInheritKeys, proxyPickerMethods } from "./utils.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { Picker } from "../picker/index.mjs";
+const [name] = createNamespace("time-picker");
+var stdin_default = defineComponent({
+  name,
+  props: extend({}, sharedProps, {
+    minHour: makeNumericProp(0),
+    maxHour: makeNumericProp(23),
+    minMinute: makeNumericProp(0),
+    maxMinute: makeNumericProp(59),
+    modelValue: String
+  }),
+  emits: ["confirm", "cancel", "change", "update:modelValue"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const formatValue = (value) => {
+      const {
+        minHour,
+        maxHour,
+        maxMinute,
+        minMinute
+      } = props;
+      if (!value) {
+        value = `${padZero(minHour)}:${padZero(minMinute)}`;
+      }
+      let [hour, minute] = value.split(":");
+      hour = padZero(clamp(+hour, +minHour, +maxHour));
+      minute = padZero(clamp(+minute, +minMinute, +maxMinute));
+      return `${hour}:${minute}`;
+    };
+    const picker = ref();
+    const currentDate = ref(formatValue(props.modelValue));
+    const ranges = computed(() => [{
+      type: "hour",
+      range: [+props.minHour, +props.maxHour]
+    }, {
+      type: "minute",
+      range: [+props.minMinute, +props.maxMinute]
+    }]);
+    const originColumns = computed(() => ranges.value.map(({
+      type,
+      range: rangeArr
+    }) => {
+      let values = times(rangeArr[1] - rangeArr[0] + 1, (index) => padZero(rangeArr[0] + index));
+      if (props.filter) {
+        values = props.filter(type, values);
+      }
+      return {
+        type,
+        values
+      };
+    }));
+    const columns = computed(() => originColumns.value.map((column) => ({
+      values: column.values.map((value) => props.formatter(column.type, value))
+    })));
+    const updateColumnValue = () => {
+      const pair = currentDate.value.split(":");
+      const values = [props.formatter("hour", pair[0]), props.formatter("minute", pair[1])];
+      nextTick(() => {
+        var _a;
+        (_a = picker.value) == null ? void 0 : _a.setValues(values);
+      });
+    };
+    const updateInnerValue = () => {
+      const [hourIndex, minuteIndex] = picker.value.getIndexes();
+      const [hourColumn, minuteColumn] = originColumns.value;
+      const hour = hourColumn.values[hourIndex] || hourColumn.values[0];
+      const minute = minuteColumn.values[minuteIndex] || minuteColumn.values[0];
+      currentDate.value = formatValue(`${hour}:${minute}`);
+      updateColumnValue();
+    };
+    const onConfirm = () => emit("confirm", currentDate.value);
+    const onCancel = () => emit("cancel");
+    const onChange = () => {
+      updateInnerValue();
+      nextTick(() => {
+        nextTick(() => emit("change", currentDate.value));
+      });
+    };
+    onMounted(() => {
+      updateColumnValue();
+      nextTick(updateInnerValue);
+    });
+    watch(columns, updateColumnValue);
+    watch(() => [props.filter, props.maxHour, props.minMinute, props.maxMinute], updateInnerValue);
+    watch(() => props.minHour, () => {
+      nextTick(updateInnerValue);
+    });
+    watch(currentDate, (value) => emit("update:modelValue", value));
+    watch(() => props.modelValue, (value) => {
+      value = formatValue(value);
+      if (value !== currentDate.value) {
+        currentDate.value = value;
+        updateColumnValue();
+      }
+    });
+    useExpose({
+      getPicker: () => picker.value && proxyPickerMethods(picker.value, updateInnerValue)
+    });
+    return () => _createVNode(Picker, _mergeProps({
+      "ref": picker,
+      "columns": columns.value,
+      "onChange": onChange,
+      "onCancel": onCancel,
+      "onConfirm": onConfirm
+    }, pick(props, pickerInheritKeys)), slots);
+  }
+});
+export {
+  stdin_default as default
+};

package/es/datetime-picker/index.d.ts

@@ -0,0 +1,12 @@
+import { DatetimePickerProps } from './DatetimePicker';
+export declare const DatetimePicker: import("../utils").WithInstall<import("vue").DefineComponent<any, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<any>, {} | {
+    [x: string]: any;
+}>>;
+export default DatetimePicker;
+export type { DatetimePickerProps };
+export type { DatetimePickerType, DatetimePickerInstance } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanDatetimePicker: typeof DatetimePicker;
+    }
+}

package/es/datetime-picker/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _DatetimePicker from "./DatetimePicker.mjs";
+const DatetimePicker = withInstall(_DatetimePicker);
+var stdin_default = DatetimePicker;
+export {
+  DatetimePicker,
+  stdin_default as default
+};

package/es/datetime-picker/style/index.mjs

@@ -0,0 +1,3 @@
+import "../../style/base.css";
+import "../../loading/index.css";
+import "../../picker/index.css";

package/es/datetime-picker/style/less.mjs

@@ -0,0 +1,3 @@
+import "../../style/base.less";
+import "../../loading/index.less";
+import "../../picker/index.less";

package/es/datetime-picker/types.d.ts

@@ -0,0 +1,9 @@
+import { ComponentPublicInstance } from 'vue';
+import type { PickerInstance } from '../picker';
+import { DatetimePickerProps } from './DatetimePicker';
+export declare type DatetimePickerColumnType = 'year' | 'month' | 'day' | 'hour' | 'minute';
+export declare type DatetimePickerType = 'date' | 'time' | 'datetime' | 'datehour' | 'month-day' | 'year-month';
+export declare type DatetimePickerExpose = {
+    getPicker: () => PickerInstance;
+};
+export declare type DatetimePickerInstance = ComponentPublicInstance<DatetimePickerProps, DatetimePickerExpose>;

package/es/datetime-picker/utils.d.ts

@@ -0,0 +1,39 @@
+import type { PropType } from 'vue';
+import type { PickerInstance } from '../picker';
+import type { DatetimePickerColumnType } from './types';
+export declare const sharedProps: {
+    title: StringConstructor;
+    loading: BooleanConstructor;
+    readonly: BooleanConstructor;
+    allowHtml: BooleanConstructor;
+    itemHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    showToolbar: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    swipeDuration: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    visibleItemCount: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    cancelButtonText: StringConstructor;
+    confirmButtonText: StringConstructor;
+} & {
+    filter: PropType<(type: string, values: string[]) => string[]>;
+    columnsOrder: PropType<DatetimePickerColumnType[]>;
+    formatter: {
+        type: PropType<(type: string, value: string) => string>;
+        default: (type: string, value: string) => string;
+    };
+};
+export declare const pickerInheritKeys: ("title" | "readonly" | "loading" | "allowHtml" | "itemHeight" | "showToolbar" | "swipeDuration" | "visibleItemCount" | "cancelButtonText" | "confirmButtonText")[];
+export declare function times<T>(n: number, iteratee: (index: number) => T): T[];
+export declare function getTrueValue(value: string | undefined): number;
+export declare const getMonthEndDay: (year: number, month: number) => number;
+export declare const proxyPickerMethods: (picker: PickerInstance, callback: () => void) => PickerInstance;

package/es/datetime-picker/utils.mjs

@@ -0,0 +1,63 @@
+import { extend } from "../utils/index.mjs";
+import { pickerSharedProps } from "../picker/Picker.mjs";
+const sharedProps = extend({}, pickerSharedProps, {
+  filter: Function,
+  columnsOrder: Array,
+  formatter: {
+    type: Function,
+    default: (type, value) => value
+  }
+});
+const pickerInheritKeys = Object.keys(pickerSharedProps);
+function times(n, iteratee) {
+  if (n < 0) {
+    return [];
+  }
+  const result = Array(n);
+  let index = -1;
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+function getTrueValue(value) {
+  if (!value) {
+    return 0;
+  }
+  while (Number.isNaN(parseInt(value, 10))) {
+    if (value.length > 1) {
+      value = value.slice(1);
+    } else {
+      return 0;
+    }
+  }
+  return parseInt(value, 10);
+}
+const getMonthEndDay = (year, month) => 32 - new Date(year, month - 1, 32).getDate();
+const proxyPickerMethods = (picker, callback) => {
+  const methods = [
+    "setValues",
+    "setIndexes",
+    "setColumnIndex",
+    "setColumnValue"
+  ];
+  return new Proxy(picker, {
+    get: (target, prop) => {
+      if (methods.includes(prop)) {
+        return (...args) => {
+          target[prop](...args);
+          callback();
+        };
+      }
+      return target[prop];
+    }
+  });
+};
+export {
+  getMonthEndDay,
+  getTrueValue,
+  pickerInheritKeys,
+  proxyPickerMethods,
+  sharedProps,
+  times
+};

package/es/dialog/Dialog.d.ts

@@ -1,6 +1,6 @@
 import { type PropType, type ExtractPropTypes } from 'vue';
 import type { DialogTheme, DialogAction, DialogMessage, DialogMessageAlign } from './types';
-export declare const dialogProps: {
+declare const dialogProps: {
     show: BooleanConstructor;
     zIndex: (NumberConstructor | StringConstructor)[];
     overlay: {
@@ -8,7 +8,7 @@ export declare const dialogProps: {
         default: true;
     };
     duration: (NumberConstructor | StringConstructor)[];
-    teleport: PropType<import("vue").TeleportProps["to"]>;
+    teleport: PropType<string | import("vue").RendererElement | null | undefined>;
     lockScroll: {
         type: BooleanConstructor;
         default: true;
@@ -34,7 +34,7 @@ export declare const dialogProps: {
     allowHtml: BooleanConstructor;
     className: PropType<unknown>;
     transition: {
-        type: PropType<T>;
+        type: PropType<string>;
         default: string;
     };
     messageAlign: PropType<DialogMessageAlign>;
@@ -54,13 +54,9 @@ export declare const dialogProps: {
         default: true;
     };
     closeOnClickOverlay: BooleanConstructor;
-    keyboardEnabled: {
-        type: BooleanConstructor;
-        default: true;
-    };
 };
-export type DialogProps = ExtractPropTypes<typeof dialogProps>;
-declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+export declare type DialogProps = ExtractPropTypes<typeof dialogProps>;
+declare const _default: import("vue").DefineComponent<{
     show: BooleanConstructor;
     zIndex: (NumberConstructor | StringConstructor)[];
     overlay: {
@@ -68,7 +64,7 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
         default: true;
     };
     duration: (NumberConstructor | StringConstructor)[];
-    teleport: PropType<import("vue").TeleportProps["to"]>;
+    teleport: PropType<string | import("vue").RendererElement | null | undefined>;
     lockScroll: {
         type: BooleanConstructor;
         default: true;
@@ -90,11 +86,11 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     theme: PropType<DialogTheme>;
     width: (NumberConstructor | StringConstructor)[];
     message: PropType<DialogMessage>;
-    callback: PropType<(action?: DialogAction) => void>;
+    callback: PropType<(action?: DialogAction | undefined) => void>;
     allowHtml: BooleanConstructor;
     className: PropType<unknown>;
     transition: {
-        type: PropType<T>;
+        type: PropType<string>;
         default: string;
     };
     messageAlign: PropType<DialogMessageAlign>;
@@ -114,11 +110,7 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
         default: true;
     };
     closeOnClickOverlay: BooleanConstructor;
-    keyboardEnabled: {
-        type: BooleanConstructor;
-        default: true;
-    };
-}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "keydown" | "update:show" | "confirm")[], "cancel" | "keydown" | "update:show" | "confirm", import("vue").PublicProps, Readonly<ExtractPropTypes<{
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("keydown" | "update:show" | "cancel" | "confirm")[], "keydown" | "update:show" | "cancel" | "confirm", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
     show: BooleanConstructor;
     zIndex: (NumberConstructor | StringConstructor)[];
     overlay: {
@@ -126,7 +118,7 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
         default: true;
     };
     duration: (NumberConstructor | StringConstructor)[];
-    teleport: PropType<import("vue").TeleportProps["to"]>;
+    teleport: PropType<string | import("vue").RendererElement | null | undefined>;
     lockScroll: {
         type: BooleanConstructor;
         default: true;
@@ -148,11 +140,11 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     theme: PropType<DialogTheme>;
     width: (NumberConstructor | StringConstructor)[];
     message: PropType<DialogMessage>;
-    callback: PropType<(action?: DialogAction) => void>;
+    callback: PropType<(action?: DialogAction | undefined) => void>;
     allowHtml: BooleanConstructor;
     className: PropType<unknown>;
     transition: {
-        type: PropType<T>;
+        type: PropType<string>;
         default: string;
     };
     messageAlign: PropType<DialogMessageAlign>;
@@ -172,16 +164,12 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
         default: true;
     };
     closeOnClickOverlay: BooleanConstructor;
-    keyboardEnabled: {
-        type: BooleanConstructor;
-        default: true;
-    };
-}>> & Readonly<{
+}>> & {
     onKeydown?: ((...args: any[]) => any) | undefined;
     "onUpdate:show"?: ((...args: any[]) => any) | undefined;
     onCancel?: ((...args: any[]) => any) | undefined;
     onConfirm?: ((...args: any[]) => any) | undefined;
-}>, {
+}, {
     overlay: boolean;
     show: boolean;
     lockScroll: boolean;
@@ -195,6 +183,5 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     cancelButtonDisabled: boolean;
     confirmButtonDisabled: boolean;
     showConfirmButton: boolean;
-    keyboardEnabled: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>;
 export default _default;

package/es/dialog/Dialog.mjs

@@ -1,4 +1,5 @@
-import { ref, reactive, withKeys, defineComponent, createVNode as _createVNode, mergeProps as _mergeProps } from "vue";
+import { mergeProps as _mergeProps, createVNode as _createVNode } from "vue";
+import { ref, reactive, withKeys, defineComponent } from "vue";
 import { noop, pick, extend, addUnit, truthProp, isFunction, BORDER_TOP, BORDER_LEFT, unknownProp, numericProp, makeStringProp, callInterceptor, createNamespace } from "../utils/index.mjs";
 import { popupSharedProps, popupSharedPropKeys } from "../popup/shared.mjs";
 import { Popup } from "../popup/index.mjs";
@@ -25,8 +26,7 @@ const dialogProps = extend({}, popupSharedProps, {
   confirmButtonColor: String,
   confirmButtonDisabled: Boolean,
   showConfirmButton: truthProp,
-  closeOnClickOverlay: Boolean,
-  keyboardEnabled: truthProp
+  closeOnClickOverlay: Boolean
 });
 const popupInheritKeys = [...popupSharedPropKeys, "transition", "closeOnPopstate"];
 var stdin_default = defineComponent({
@@ -73,9 +73,6 @@ var stdin_default = defineComponent({
     const onConfirm = getActionHandler("confirm");
     const onKeydown = withKeys((event) => {
       var _a, _b;
-      if (!props.keyboardEnabled) {
-        return;
-      }
       if (event.target !== ((_b = (_a = root.value) == null ? void 0 : _a.popupRef) == null ? void 0 : _b.value)) {
         return;
       }
@@ -216,6 +213,5 @@ var stdin_default = defineComponent({
   }
 });
 export {
-  stdin_default as default,
-  dialogProps
+  stdin_default as default
 };

package/es/dialog/function-call.d.ts

@@ -1,21 +1,194 @@
+import { App } from 'vue';
 import type { DialogAction, DialogOptions } from './types';
-/**
- * Display a message prompt dialog with a default confirm button
- */
-export declare function showDialog(options: DialogOptions): Promise<DialogAction | undefined>;
-/**
- * Modify the default configuration that affects all `showDialog` calls
- */
-export declare const setDialogDefaultOptions: (options: DialogOptions) => void;
-/**
- * Reset the default configuration that affects all `showDialog` calls
- */
-export declare const resetDialogDefaultOptions: () => void;
-/**
- * Display a message confirmation dialog with default confirm and cancel buttons
- */
-export declare const showConfirmDialog: (options: DialogOptions) => Promise<DialogAction | undefined>;
-/**
- * Close the currently displayed dialog
- */
-export declare const closeDialog: () => void;
+declare function Dialog(options: DialogOptions): Promise<unknown>;
+declare namespace Dialog {
+    var defaultOptions: {
+        title: string;
+        width: string;
+        theme: null;
+        message: string;
+        overlay: boolean;
+        callback: null;
+        teleport: string;
+        className: string;
+        allowHtml: boolean;
+        lockScroll: boolean;
+        transition: undefined;
+        beforeClose: null;
+        overlayClass: string;
+        overlayStyle: undefined;
+        messageAlign: string;
+        cancelButtonText: string;
+        cancelButtonColor: null;
+        cancelButtonDisabled: boolean;
+        confirmButtonText: string;
+        confirmButtonColor: null;
+        confirmButtonDisabled: boolean;
+        showConfirmButton: boolean;
+        showCancelButton: boolean;
+        closeOnPopstate: boolean;
+        closeOnClickOverlay: boolean;
+    };
+    var currentOptions: {
+        title: string;
+        width: string;
+        theme: null;
+        message: string;
+        overlay: boolean;
+        callback: null;
+        teleport: string;
+        className: string;
+        allowHtml: boolean;
+        lockScroll: boolean;
+        transition: undefined;
+        beforeClose: null;
+        overlayClass: string;
+        overlayStyle: undefined;
+        messageAlign: string;
+        cancelButtonText: string;
+        cancelButtonColor: null;
+        cancelButtonDisabled: boolean;
+        confirmButtonText: string;
+        confirmButtonColor: null;
+        confirmButtonDisabled: boolean;
+        showConfirmButton: boolean;
+        showCancelButton: boolean;
+        closeOnPopstate: boolean;
+        closeOnClickOverlay: boolean;
+    };
+    var alert: typeof Dialog;
+    var confirm: (options: DialogOptions) => Promise<unknown>;
+    var close: () => void;
+    var setDefaultOptions: (options: DialogOptions) => void;
+    var resetDefaultOptions: () => void;
+    var Component: import("../utils").WithInstall<import("vue").DefineComponent<{
+        show: BooleanConstructor;
+        zIndex: (NumberConstructor | StringConstructor)[];
+        overlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        duration: (NumberConstructor | StringConstructor)[];
+        teleport: import("vue").PropType<string | import("vue").RendererElement | null | undefined>;
+        lockScroll: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        lazyRender: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        beforeClose: import("vue").PropType<import("../utils").Interceptor>;
+        overlayStyle: import("vue").PropType<import("vue").CSSProperties>;
+        overlayClass: import("vue").PropType<unknown>;
+        transitionAppear: BooleanConstructor;
+        closeOnClickOverlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+    } & {
+        title: StringConstructor;
+        theme: import("vue").PropType<import("./types").DialogTheme>;
+        width: (NumberConstructor | StringConstructor)[];
+        message: import("vue").PropType<import("./types").DialogMessage>;
+        callback: import("vue").PropType<(action?: DialogAction | undefined) => void>;
+        allowHtml: BooleanConstructor;
+        className: import("vue").PropType<unknown>;
+        transition: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        messageAlign: import("vue").PropType<import("./types").DialogMessageAlign>;
+        closeOnPopstate: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        showCancelButton: BooleanConstructor;
+        cancelButtonText: StringConstructor;
+        cancelButtonColor: StringConstructor;
+        cancelButtonDisabled: BooleanConstructor;
+        confirmButtonText: StringConstructor;
+        confirmButtonColor: StringConstructor;
+        confirmButtonDisabled: BooleanConstructor;
+        showConfirmButton: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        closeOnClickOverlay: BooleanConstructor;
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("keydown" | "update:show" | "cancel" | "confirm")[], "keydown" | "update:show" | "cancel" | "confirm", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        show: BooleanConstructor;
+        zIndex: (NumberConstructor | StringConstructor)[];
+        overlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        duration: (NumberConstructor | StringConstructor)[];
+        teleport: import("vue").PropType<string | import("vue").RendererElement | null | undefined>;
+        lockScroll: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        lazyRender: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        beforeClose: import("vue").PropType<import("../utils").Interceptor>;
+        overlayStyle: import("vue").PropType<import("vue").CSSProperties>;
+        overlayClass: import("vue").PropType<unknown>;
+        transitionAppear: BooleanConstructor;
+        closeOnClickOverlay: {
+            type: BooleanConstructor;
+            default: true;
+        };
+    } & {
+        title: StringConstructor;
+        theme: import("vue").PropType<import("./types").DialogTheme>;
+        width: (NumberConstructor | StringConstructor)[];
+        message: import("vue").PropType<import("./types").DialogMessage>;
+        callback: import("vue").PropType<(action?: DialogAction | undefined) => void>;
+        allowHtml: BooleanConstructor;
+        className: import("vue").PropType<unknown>;
+        transition: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        messageAlign: import("vue").PropType<import("./types").DialogMessageAlign>;
+        closeOnPopstate: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        showCancelButton: BooleanConstructor;
+        cancelButtonText: StringConstructor;
+        cancelButtonColor: StringConstructor;
+        cancelButtonDisabled: BooleanConstructor;
+        confirmButtonText: StringConstructor;
+        confirmButtonColor: StringConstructor;
+        confirmButtonDisabled: BooleanConstructor;
+        showConfirmButton: {
+            type: BooleanConstructor;
+            default: true;
+        };
+        closeOnClickOverlay: BooleanConstructor;
+    }>> & {
+        onKeydown?: ((...args: any[]) => any) | undefined;
+        "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+        onCancel?: ((...args: any[]) => any) | undefined;
+        onConfirm?: ((...args: any[]) => any) | undefined;
+    }, {
+        overlay: boolean;
+        show: boolean;
+        lockScroll: boolean;
+        lazyRender: boolean;
+        transitionAppear: boolean;
+        closeOnClickOverlay: boolean;
+        transition: string;
+        closeOnPopstate: boolean;
+        allowHtml: boolean;
+        showCancelButton: boolean;
+        cancelButtonDisabled: boolean;
+        confirmButtonDisabled: boolean;
+        showConfirmButton: boolean;
+    }>>;
+    var install: (app: App<any>) => void;
+}
+export { Dialog };