ep-craft 0.1.19 → 0.1.21

package/dist/directives/trap-focus/index.d.ts

@@ -0,0 +1,9 @@
+import type { ObjectDirective } from 'vue';
+export declare const FOCUSABLE_CHILDREN = "_trap-focus-children";
+export declare const TRAP_FOCUS_HANDLER = "_trap-focus-handler";
+export interface TrapFocusElement extends HTMLElement {
+    [FOCUSABLE_CHILDREN]: HTMLElement[];
+    [TRAP_FOCUS_HANDLER]: (e: KeyboardEvent) => void;
+}
+declare const TrapFocus: ObjectDirective;
+export default TrapFocus;

package/dist/hooks/index.d.ts

@@ -0,0 +1,17 @@
+export * from './use-namespace';
+export * from './use-ordered-children';
+export * from './use-locale';
+export * from './use-id';
+export * from './use-prop';
+export * from './use-size';
+export * from './use-deprecated';
+export * from './use-popper';
+export * from './use-popper-container';
+export * from './use-z-index';
+export * from './use-delayed-toggle';
+export * from './use-aria';
+export * from './use-model-toggle';
+export * from './use-forward-ref';
+export * from './use-empty-values';
+export * from './use-escape-keydown';
+export * from './use-timeout';

package/dist/hooks/use-aria/index.d.ts

@@ -0,0 +1,37 @@
+export interface AriaProps {
+    /**
+     * @description native `aria-label` attribute
+     */
+    ariaLabel?: string;
+    /**
+     * @description native `aria-orientation` attribute
+     */
+    ariaOrientation?: 'horizontal' | 'vertical' | 'undefined';
+    /**
+     * @description native `aria-controls` attribute
+     */
+    ariaControls?: string;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `AriaProps` instead.
+ */
+export declare const ariaProps: {
+    ariaLabel: StringConstructor;
+    ariaOrientation: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    ariaControls: StringConstructor;
+};
+export declare const useAriaProps: <T extends keyof typeof ariaProps>(arias: Array<T>) => Pick<{
+    ariaLabel: StringConstructor;
+    ariaOrientation: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    ariaControls: StringConstructor;
+}, T>;

package/dist/hooks/use-aria/index.js

@@ -0,0 +1,24 @@
+import { buildProps as i } from "../../utils/vue/props/runtime.js";
+import "vue";
+import o from "../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/pick.js";
+const t = i({
+  /**
+   * @description native `aria-label` attribute
+   */
+  ariaLabel: String,
+  /**
+   * @description native `aria-orientation` attribute
+   */
+  ariaOrientation: {
+    type: String,
+    values: ["horizontal", "vertical", "undefined"]
+  },
+  /**
+   * @description native `aria-controls` attribute
+   */
+  ariaControls: String
+}), p = (r) => o(t, r);
+export {
+  t as ariaProps,
+  p as useAriaProps
+};

package/dist/hooks/use-delayed-toggle/index.d.ts

@@ -0,0 +1,36 @@
+import type { ToRefs } from 'vue';
+export interface UseDelayedToggleProps {
+    /**
+     * @description delay of appearance, in millisecond, not valid in controlled mode
+     */
+    showAfter?: number;
+    /**
+     * @description delay of disappear, in millisecond, not valid in controlled mode
+     */
+    hideAfter?: number;
+    /**
+     * @description disappear automatically, in millisecond, not valid in controlled mode
+     */
+    autoClose?: number;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `UseDelayedToggleProps` instead.
+ */
+export declare const useDelayedToggleProps: {
+    readonly showAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly hideAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
+    readonly autoClose: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+};
+export type DelayedToggle = {
+    open: (event?: Event) => void;
+    close: (event?: Event) => void;
+} & ToRefs<Required<UseDelayedToggleProps>>;
+export declare const useDelayedTogglePropsDefaults: {
+    readonly showAfter: 0;
+    readonly hideAfter: 200;
+    readonly autoClose: 0;
+};
+export declare const useDelayedToggle: ({ showAfter, hideAfter, autoClose, open, close, }: DelayedToggle) => {
+    onOpen: (event?: Event, delay?: number) => void;
+    onClose: (event?: Event, delay?: number) => void;
+};

package/dist/hooks/use-delayed-toggle/index.js

@@ -0,0 +1,63 @@
+import { unref as r } from "vue";
+import { isNumber as c } from "../../utils/types.js";
+import { buildProps as d } from "../../utils/vue/props/runtime.js";
+import { useTimeout as l } from "../use-timeout/index.js";
+const h = d({
+  /**
+   * @description delay of appearance, in millisecond, not valid in controlled mode
+   */
+  showAfter: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description delay of disappear, in millisecond, not valid in controlled mode
+   */
+  hideAfter: {
+    type: Number,
+    default: 200
+  },
+  /**
+   * @description disappear automatically, in millisecond, not valid in controlled mode
+   */
+  autoClose: {
+    type: Number,
+    default: 0
+  }
+}), D = {
+  showAfter: 0,
+  hideAfter: 200,
+  autoClose: 0
+}, N = ({
+  showAfter: i,
+  hideAfter: m,
+  autoClose: n,
+  open: f,
+  close: s
+}) => {
+  const { registerTimeout: u } = l(), {
+    registerTimeout: p,
+    cancelTimeout: a
+  } = l();
+  return {
+    onOpen: (e, o = r(i)) => {
+      u(() => {
+        f(e);
+        const t = r(n);
+        c(t) && t > 0 && p(() => {
+          s(e);
+        }, t);
+      }, o);
+    },
+    onClose: (e, o = r(m)) => {
+      a(), u(() => {
+        s(e);
+      }, o);
+    }
+  };
+};
+export {
+  N as useDelayedToggle,
+  h as useDelayedToggleProps,
+  D as useDelayedTogglePropsDefaults
+};

package/dist/hooks/use-deprecated/index.d.ts

@@ -0,0 +1,11 @@
+import type { MaybeRef } from 'vue';
+type DeprecationParam = {
+    from: string;
+    replacement: string;
+    scope: string;
+    version: string;
+    ref: string;
+    type?: 'API' | 'Attribute' | 'Event' | 'Slot';
+};
+export declare const useDeprecated: ({ from, replacement, scope, version, ref, type }: DeprecationParam, condition: MaybeRef<boolean>) => void;
+export {};

package/dist/hooks/use-empty-values/index.d.ts

@@ -0,0 +1,29 @@
+import type { InjectionKey, Ref } from 'vue';
+type ValueOnClear = string | number | boolean | Function | null;
+export interface UseEmptyValuesProps {
+    /**
+     * @description empty values supported by the component
+     */
+    emptyValues?: unknown[];
+    /**
+     * @description return value when cleared, if you want to set `undefined`, use `() => undefined`
+     */
+    valueOnClear?: ValueOnClear;
+}
+export declare const emptyValuesContextKey: InjectionKey<Ref<UseEmptyValuesProps>>;
+export declare const SCOPE = "use-empty-values";
+export declare const DEFAULT_EMPTY_VALUES: (string | null | undefined)[];
+export declare const DEFAULT_VALUE_ON_CLEAR: undefined;
+/**
+ * @deprecated Removed after 3.0.0, Use `UseEmptyValuesProps` instead.
+ */
+export declare const useEmptyValuesProps: {
+    readonly emptyValues: ArrayConstructor;
+    readonly valueOnClear: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+};
+export declare const useEmptyValues: (props: UseEmptyValuesProps, defaultValue?: null | undefined) => {
+    emptyValues: import("vue").ComputedRef<unknown[]>;
+    valueOnClear: import("vue").ComputedRef<any>;
+    isEmptyValue: (value: unknown) => boolean;
+};
+export {};

package/dist/hooks/use-empty-values/index.js

@@ -0,0 +1,23 @@
+import "vue";
+import { isFunction as i, isArray as o } from "../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { buildProps as t, definePropType as n } from "../../utils/vue/props/runtime.js";
+t({
+  /**
+   * @description empty values supported by the component
+   */
+  emptyValues: Array,
+  /**
+   * @description return value when cleared, if you want to set `undefined`, use `() => undefined`
+   */
+  valueOnClear: {
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-function-type */
+    type: n([
+      String,
+      Number,
+      Boolean,
+      Function
+    ]),
+    default: void 0,
+    validator: (r) => (r = i(r) ? r() : r, o(r) ? r.every((e) => !e) : !r)
+  }
+});

package/dist/hooks/use-escape-keydown/index.d.ts

@@ -0,0 +1 @@
+export declare const useEscapeKeydown: (handler: (e: KeyboardEvent) => void) => void;

package/dist/hooks/use-escape-keydown/index.js

@@ -0,0 +1,21 @@
+import { onMounted as d, onBeforeUnmount as c } from "vue";
+import { getEventCode as s } from "../../utils/dom/event.js";
+import { EVENT_CODE as f } from "../../constants/aria.js";
+import { isClient as n } from "../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+let e = [];
+const r = (o) => {
+  s(o) === f.esc && e.forEach(
+    (i) => i(o)
+  );
+}, l = (o) => {
+  d(() => {
+    e.length === 0 && document.addEventListener("keydown", r), n && e.push(o);
+  }), c(() => {
+    e = e.filter(
+      (t) => t !== o
+    ), e.length === 0 && n && document.removeEventListener("keydown", r);
+  });
+};
+export {
+  l as useEscapeKeydown
+};

package/dist/hooks/use-forward-ref/index.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey, ObjectDirective, Ref } from 'vue';
+type ForwardRefSetter = <T>(el: T) => void;
+export type ForwardRefInjectionContext = {
+    setForwardRef: ForwardRefSetter;
+};
+export declare const FORWARD_REF_INJECTION_KEY: InjectionKey<ForwardRefInjectionContext>;
+export declare const useForwardRef: <T>(forwardRef: Ref<T | null>) => void;
+export declare const useForwardRefDirective: (setForwardRef: ForwardRefSetter) => ObjectDirective;
+export {};

package/dist/hooks/use-forward-ref/index.js

@@ -0,0 +1,23 @@
+import { provide as t } from "vue";
+const n = Symbol("elForwardRef"), d = (e) => {
+  t(n, {
+    setForwardRef: (r) => {
+      e.value = r;
+    }
+  });
+}, s = (e) => ({
+  mounted(o) {
+    e(o);
+  },
+  updated(o) {
+    e(o);
+  },
+  unmounted() {
+    e(null);
+  }
+});
+export {
+  n as FORWARD_REF_INJECTION_KEY,
+  d as useForwardRef,
+  s as useForwardRefDirective
+};

package/dist/hooks/use-id/index.d.ts

@@ -0,0 +1,8 @@
+import type { InjectionKey, MaybeRef, Ref } from 'vue';
+export type ElIdInjectionContext = {
+    prefix: number;
+    current: number;
+};
+export declare const ID_INJECTION_KEY: InjectionKey<ElIdInjectionContext>;
+export declare const useIdInjection: () => ElIdInjectionContext;
+export declare const useId: (deterministicId?: MaybeRef<string>) => Ref<string>;

package/dist/hooks/use-id/index.js

@@ -0,0 +1,27 @@
+import { unref as t, getCurrentInstance as i, inject as c } from "vue";
+import { debugWarn as s } from "../../utils/error.js";
+import { useGetDerivedNamespace as u } from "../use-namespace/index.js";
+import { isClient as d, computedEager as a } from "../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+const r = {
+  prefix: Math.floor(Math.random() * 1e4),
+  current: 0
+}, p = Symbol("elIdInjection"), I = () => i() ? c(p, r) : r, v = (n) => {
+  const e = I();
+  !d && e === r && s(
+    "IdInjection",
+    `Looks like you are using server rendering, you must provide a id provider to ensure the hydration process to be succeed
+usage: app.provide(ID_INJECTION_KEY, {
+  prefix: number,
+  current: number,
+})`
+  );
+  const o = u();
+  return a(
+    () => t(n) || `${o.value}-id-${e.prefix}-${e.current++}`
+  );
+};
+export {
+  p as ID_INJECTION_KEY,
+  v as useId,
+  I as useIdInjection
+};

package/dist/hooks/use-locale/index.d.ts

@@ -0,0 +1,17 @@
+import English from '@element-plus/locale/lang/en';
+import type { InjectionKey, MaybeRef, Ref } from 'vue';
+import type { FieldPath } from '@element-plus/utils';
+import type { Language } from '@element-plus/locale';
+export type LocaleKeys = Exclude<FieldPath<typeof English>, 'name' | 'el'> | (string & NonNullable<unknown>);
+export type TranslatorOption = Record<string, string | number>;
+export type Translator = (path: LocaleKeys, option?: TranslatorOption) => string;
+export type LocaleContext = {
+    locale: Ref<Language>;
+    lang: Ref<string>;
+    t: Translator;
+};
+export declare const buildTranslator: (locale: MaybeRef<Language>) => Translator;
+export declare const translate: (path: LocaleKeys, option: undefined | TranslatorOption, locale: Language) => string;
+export declare const buildLocaleContext: (locale: MaybeRef<Language>) => LocaleContext;
+export declare const localeContextKey: InjectionKey<Ref<Language | undefined>>;
+export declare const useLocale: (localeOverrides?: Ref<Language | undefined>) => LocaleContext;

package/dist/hooks/use-model-toggle/index.d.ts

@@ -0,0 +1,46 @@
+import type { ExtractPropType } from '@element-plus/utils';
+import type { ExtractPropTypes, ExtractPublicPropTypes, Ref } from 'vue';
+declare const _prop: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => boolean) | (() => boolean | null) | (((new (...args: any[]) => boolean) | (() => boolean | null)) | null)[], never, never, null, false>;
+declare const _event: {
+    readonly type: import("vue").PropType<(val: boolean) => void>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+};
+export type UseModelTogglePropsRaw<T extends string> = {
+    [K in T]: typeof _prop;
+} & {
+    [K in `onUpdate:${T}`]: typeof _event;
+};
+export type UseModelTogglePropsGeneric<T extends string> = {
+    [K in T]: ExtractPropType<typeof _prop>;
+} & {
+    [K in `onUpdate:${T}`]: ExtractPropType<typeof _event>;
+};
+export declare const createModelToggleComposable: <T extends string>(name: T) => {
+    useModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: ModelToggleParams) => {
+        hide: (event?: Event) => void;
+        show: (event?: Event) => void;
+        toggle: () => void;
+        hasUpdateHandler: import("vue").ComputedRef<boolean>;
+    };
+    useModelToggleProps: UseModelTogglePropsRaw<T>;
+    useModelToggleEmits: `update:${T}`[];
+};
+declare const useModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: ModelToggleParams) => {
+    hide: (event?: Event) => void;
+    show: (event?: Event) => void;
+    toggle: () => void;
+    hasUpdateHandler: import("vue").ComputedRef<boolean>;
+}, useModelToggleProps: UseModelTogglePropsRaw<"modelValue">, useModelToggleEmits: "update:modelValue"[];
+export { useModelToggle, useModelToggleEmits, useModelToggleProps };
+export type UseModelToggleProps = ExtractPropTypes<typeof useModelToggleProps>;
+export type UseModelTogglePropsPublic = ExtractPublicPropTypes<typeof useModelToggleProps>;
+export type ModelToggleParams = {
+    indicator: Ref<boolean>;
+    toggleReason?: Ref<Event | undefined>;
+    shouldHideWhenRouteChanges?: Ref<boolean>;
+    shouldProceed?: () => boolean;
+    onShow?: (event?: Event) => void;
+    onHide?: (event?: Event) => void;
+};

package/dist/hooks/use-model-toggle/index.js

@@ -0,0 +1,67 @@
+import { getCurrentInstance as K, computed as P, watch as $, onMounted as U } from "vue";
+import { isBoolean as _ } from "../../utils/types.js";
+import { isFunction as f } from "../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { buildProp as h, definePropType as w } from "../../utils/vue/props/runtime.js";
+import { isClient as d } from "../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+const A = h({
+  type: w(Boolean),
+  default: null
+}), I = h({
+  type: w(Function)
+}), H = (s) => {
+  const u = `update:${s}`, c = `onUpdate:${s}`, x = [u], B = {
+    [s]: A,
+    [c]: I
+  };
+  return {
+    useModelToggle: ({
+      indicator: o,
+      toggleReason: r,
+      shouldHideWhenRouteChanges: g,
+      shouldProceed: v,
+      onShow: m,
+      onHide: M
+    }) => {
+      const n = K(), { emit: p } = n, t = n.props, i = P(
+        () => f(t[c])
+      ), T = P(() => t[s] === null), b = (e) => {
+        o.value !== !0 && (o.value = !0, r && (r.value = e), f(m) && m(e));
+      }, y = (e) => {
+        o.value !== !1 && (o.value = !1, r && (r.value = e), f(M) && M(e));
+      }, E = (e) => {
+        if (t.disabled === !0 || f(v) && !v())
+          return;
+        const l = i.value && d;
+        l && p(u, !0), (T.value || !l) && b(e);
+      }, a = (e) => {
+        if (t.disabled === !0 || !d) return;
+        const l = i.value && d;
+        l && p(u, !1), (T.value || !l) && y(e);
+      }, C = (e) => {
+        _(e) && (t.disabled && e ? i.value && p(u, !1) : o.value !== e && (e ? b() : y()));
+      }, F = () => {
+        o.value ? a() : E();
+      };
+      return $(() => t[s], C), g && n.appContext.config.globalProperties.$route !== void 0 && $(
+        () => ({
+          ...n.proxy.$route
+        }),
+        () => {
+          g.value && o.value && a();
+        }
+      ), U(() => {
+        C(t[s]);
+      }), {
+        hide: a,
+        show: E,
+        toggle: F,
+        hasUpdateHandler: i
+      };
+    },
+    useModelToggleProps: B,
+    useModelToggleEmits: x
+  };
+};
+export {
+  H as createModelToggleComposable
+};

package/dist/hooks/use-namespace/index.d.ts

@@ -0,0 +1,23 @@
+import type { InjectionKey, Ref } from 'vue';
+export declare const defaultNamespace = "el";
+export declare const namespaceContextKey: InjectionKey<Ref<string | undefined>>;
+export declare const useGetDerivedNamespace: (namespaceOverrides?: Ref<string | undefined>) => import("vue").ComputedRef<string>;
+export declare const useNamespace: (block: string, namespaceOverrides?: Ref<string | undefined>) => {
+    namespace: import("vue").ComputedRef<string>;
+    b: (blockSuffix?: string) => string;
+    e: (element?: string) => string;
+    m: (modifier?: string) => string;
+    be: (blockSuffix?: string, element?: string) => string;
+    em: (element?: string, modifier?: string) => string;
+    bm: (blockSuffix?: string, modifier?: string) => string;
+    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+    is: {
+        (name: string, state: boolean | undefined): string;
+        (name: string): string;
+    };
+    cssVar: (object: Record<string, string>) => Record<string, string>;
+    cssVarName: (name: string) => string;
+    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+    cssVarBlockName: (name: string) => string;
+};
+export type UseNamespaceReturn = ReturnType<typeof useNamespace>;

package/dist/hooks/use-namespace/index.js

@@ -0,0 +1,45 @@
+import { getCurrentInstance as p, inject as N, ref as v, computed as V, unref as y } from "vue";
+const $ = "el", l = "is-", c = (t, u, a, o, m) => {
+  let r = `${t}-${u}`;
+  return a && (r += `-${a}`), o && (r += `__${o}`), m && (r += `--${m}`), r;
+}, B = Symbol("namespaceContextKey"), i = (t) => {
+  const u = p() ? N(B, v($)) : v($);
+  return V(() => y(u) || $);
+}, P = (t, u) => {
+  const a = i();
+  return {
+    namespace: a,
+    b: (s = "") => c(a.value, t, s, "", ""),
+    e: (s) => s ? c(a.value, t, "", s, "") : "",
+    m: (s) => s ? c(a.value, t, "", "", s) : "",
+    be: (s, e) => s && e ? c(a.value, t, s, e, "") : "",
+    em: (s, e) => s && e ? c(a.value, t, "", s, e) : "",
+    bm: (s, e) => s && e ? c(a.value, t, s, "", e) : "",
+    bem: (s, e, n) => s && e && n ? c(a.value, t, s, e, n) : "",
+    is: (s, ...e) => {
+      const n = e.length >= 1 ? e[0] : !0;
+      return s && n ? `${l}${s}` : "";
+    },
+    // css
+    cssVar: (s) => {
+      const e = {};
+      for (const n in s)
+        s[n] && (e[`--${a.value}-${n}`] = s[n]);
+      return e;
+    },
+    cssVarName: (s) => `--${a.value}-${s}`,
+    cssVarBlock: (s) => {
+      const e = {};
+      for (const n in s)
+        s[n] && (e[`--${a.value}-${t}-${n}`] = s[n]);
+      return e;
+    },
+    cssVarBlockName: (s) => `--${a.value}-${t}-${s}`
+  };
+};
+export {
+  $ as defaultNamespace,
+  B as namespaceContextKey,
+  i as useGetDerivedNamespace,
+  P as useNamespace
+};

package/dist/hooks/use-ordered-children/index.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentInternalInstance, VNode } from 'vue';
+type ChildEssential = {
+    uid: number;
+    getVnode: () => VNode;
+};
+export declare const useOrderedChildren: <T extends ChildEssential>(vm: ComponentInternalInstance, childComponentName: string) => {
+    children: import("vue").ShallowRef<T[], T[]>;
+    addChild: (child: T) => void;
+    removeChild: (child: T) => void;
+    ChildrenSorter: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export {};

package/dist/hooks/use-popper/index.d.ts

@@ -0,0 +1,78 @@
+import type { Ref } from 'vue';
+import type { Instance, Modifier, Options, State, VirtualElement } from '@popperjs/core';
+type ElementType = HTMLElement | undefined;
+type ReferenceElement = ElementType | VirtualElement;
+export type PartialOptions = Partial<Options>;
+export declare const usePopper: (referenceElementRef: Ref<ReferenceElement>, popperElementRef: Ref<ElementType>, opts?: Ref<PartialOptions> | PartialOptions) => {
+    state: import("vue").ComputedRef<{
+        elements?: {
+            reference: Element | VirtualElement;
+            popper: HTMLElement;
+            arrow?: HTMLElement;
+        } | undefined;
+        options?: import("@popperjs/core").OptionsGeneric<any> | undefined;
+        placement?: import("element-plus").Placement | undefined;
+        strategy?: import("@popperjs/core").PositioningStrategy | undefined;
+        orderedModifiers?: Modifier<any, any>[] | undefined;
+        rects?: import("@popperjs/core").StateRects | undefined;
+        scrollParents?: {
+            reference: Array<Element | import("@popperjs/core").Window | import("@popperjs/core").VisualViewport>;
+            popper: Array<Element | import("@popperjs/core").Window | import("@popperjs/core").VisualViewport>;
+        } | undefined;
+        styles?: {
+            [key: string]: Partial<CSSStyleDeclaration>;
+        } | undefined;
+        attributes?: {
+            [key: string]: {
+                [key: string]: string | boolean;
+            };
+        } | undefined;
+        modifiersData?: {
+            [key: string]: any;
+            arrow?: {
+                x?: number;
+                y?: number;
+                centerOffset: number;
+            };
+            hide?: {
+                isReferenceHidden: boolean;
+                hasPopperEscaped: boolean;
+                referenceClippingOffsets: import("@popperjs/core").SideObject;
+                popperEscapeOffsets: import("@popperjs/core").SideObject;
+            };
+            offset?: {
+                top?: import("@popperjs/core").Offsets | undefined;
+                bottom?: import("@popperjs/core").Offsets | undefined;
+                left?: import("@popperjs/core").Offsets | undefined;
+                "top-start"?: import("@popperjs/core").Offsets | undefined;
+                "top-end"?: import("@popperjs/core").Offsets | undefined;
+                "bottom-start"?: import("@popperjs/core").Offsets | undefined;
+                "bottom-end"?: import("@popperjs/core").Offsets | undefined;
+                right?: import("@popperjs/core").Offsets | undefined;
+                auto?: import("@popperjs/core").Offsets | undefined;
+                "auto-start"?: import("@popperjs/core").Offsets | undefined;
+                "auto-end"?: import("@popperjs/core").Offsets | undefined;
+                "right-start"?: import("@popperjs/core").Offsets | undefined;
+                "right-end"?: import("@popperjs/core").Offsets | undefined;
+                "left-start"?: import("@popperjs/core").Offsets | undefined;
+                "left-end"?: import("@popperjs/core").Offsets | undefined;
+            };
+            preventOverflow?: import("@popperjs/core").Offsets;
+            popperOffsets?: import("@popperjs/core").Offsets;
+        } | undefined;
+        reset?: boolean | undefined;
+    }>;
+    styles: import("vue").ComputedRef<{
+        [key: string]: Partial<CSSStyleDeclaration>;
+    }>;
+    attributes: import("vue").ComputedRef<{
+        [key: string]: {
+            [key: string]: string | boolean;
+        };
+    }>;
+    update: () => Promise<Partial<State>> | undefined;
+    forceUpdate: () => void | undefined;
+    instanceRef: import("vue").ComputedRef<Instance | undefined>;
+};
+export type UsePopperReturn = ReturnType<typeof usePopper>;
+export {};