@evance/evance-ui 1.0.0

package/dist/components/EvOverlay/activator.d.ts

@@ -0,0 +1,227 @@
+import { ComponentInternalInstance, ComponentPublicInstance, ComputedRef, PropType, Ref } from 'vue';
+import { DelayOpenCloseProps } from '../../composables/delay.ts';
+
+type ActivatorSelector = 'parent' | string | Element | ComponentPublicInstance;
+export interface ActivatorProps extends DelayOpenCloseProps {
+    activator?: ActivatorSelector;
+    activatorProps: Record<string, any>;
+    openOnClick: boolean | undefined;
+    openOnHover: boolean;
+    openOnFocus: boolean | undefined;
+    closeOnContentClick: boolean;
+}
+export declare const makeActivatorProps: <Defaults extends {
+    closeDelay?: unknown;
+    openDelay?: unknown;
+    activator?: unknown;
+    activatorProps?: unknown;
+    openOnClick?: unknown;
+    openOnHover?: unknown;
+    openOnFocus?: unknown;
+    closeOnContentClick?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    closeDelay: unknown extends Defaults["closeDelay"] ? (StringConstructor | NumberConstructor)[] : {
+        type: PropType<unknown extends Defaults["closeDelay"] ? string | number : NonNullable<string | number> | Defaults["closeDelay"]>;
+        default: unknown extends Defaults["closeDelay"] ? string | number : NonNullable<string | number> | Defaults["closeDelay"];
+    };
+    openDelay: unknown extends Defaults["openDelay"] ? (StringConstructor | NumberConstructor)[] : {
+        type: PropType<unknown extends Defaults["openDelay"] ? string | number : NonNullable<string | number> | Defaults["openDelay"]>;
+        default: unknown extends Defaults["openDelay"] ? string | number : NonNullable<string | number> | Defaults["openDelay"];
+    };
+    activator: unknown extends Defaults["activator"] ? PropType<ActivatorSelector | undefined> : {
+        type: PropType<unknown extends Defaults["activator"] ? ActivatorSelector | undefined : Defaults["activator"] | NonNullable<ActivatorSelector | undefined>>;
+        default: unknown extends Defaults["activator"] ? ActivatorSelector | undefined : Defaults["activator"] | NonNullable<ActivatorSelector | undefined>;
+    };
+    activatorProps: unknown extends Defaults["activatorProps"] ? {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    } : Omit<{
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["activatorProps"] ? Record<string, any> : Record<string, any> | Defaults["activatorProps"]>;
+        default: unknown extends Defaults["activatorProps"] ? Record<string, any> : Record<string, any> | Defaults["activatorProps"];
+    };
+    openOnClick: unknown extends Defaults["openOnClick"] ? {
+        type: BooleanConstructor;
+        default: undefined;
+    } : Omit<{
+        type: BooleanConstructor;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["openOnClick"] ? boolean : boolean | Defaults["openOnClick"]>;
+        default: unknown extends Defaults["openOnClick"] ? boolean : boolean | Defaults["openOnClick"];
+    };
+    openOnHover: unknown extends Defaults["openOnHover"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["openOnHover"] ? boolean : boolean | Defaults["openOnHover"]>;
+        default: unknown extends Defaults["openOnHover"] ? boolean : boolean | Defaults["openOnHover"];
+    };
+    openOnFocus: unknown extends Defaults["openOnFocus"] ? {
+        type: BooleanConstructor;
+        default: undefined;
+    } : Omit<{
+        type: BooleanConstructor;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["openOnFocus"] ? boolean : boolean | Defaults["openOnFocus"]>;
+        default: unknown extends Defaults["openOnFocus"] ? boolean : boolean | Defaults["openOnFocus"];
+    };
+    closeOnContentClick: unknown extends Defaults["closeOnContentClick"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["closeOnContentClick"] ? boolean : boolean | Defaults["closeOnContentClick"]>;
+        default: unknown extends Defaults["closeOnContentClick"] ? boolean : boolean | Defaults["closeOnContentClick"];
+    };
+};
+interface ActivatorEvents {
+    onBlur?: (e: FocusEvent) => void;
+    onClick?: (e: MouseEvent) => void;
+    onFocus?: (e: FocusEvent) => void;
+    onMouseenter?: (e: MouseEvent) => void;
+    onMouseleave?: (e: MouseEvent) => void;
+}
+interface ContentEvents {
+    onMouseenter?: () => void;
+    onMouseleave?: () => void;
+    onFocusin?: () => void;
+    onFocusout?: () => void;
+    onClick?: () => void;
+}
+interface VeilEvents {
+    onMouseenter?: () => void;
+    onMouseleave?: () => void;
+}
+/**
+ * # UI Mouse Event
+ * `sourceCapabilities` is in labs according to MDN. So it is subject to change.
+ * It is also not included in TypeScript's MouseEvent, so this is a little bit
+ * of a hack to avoid issues with the build.
+ */
+interface UIMouseEvent extends MouseEvent {
+    sourceCapabilities?: {
+        firesTouchEvents: boolean;
+    };
+}
+/**
+ * # Use Activator
+ *
+ * @param props
+ * @param isActive
+ * @param isTopOfStack
+ */
+export declare function useActivator(props: ActivatorProps, isActive: Ref<boolean>, isTopOfStack: Ref<boolean>): Activator;
+declare class Activator {
+    props: ActivatorProps;
+    isActive: Ref<boolean>;
+    isTopOfStack: Ref<boolean>;
+    readonly activatorEl: Ref<HTMLElement | undefined>;
+    readonly activatorEvents: ComputedRef<Partial<ActivatorEvents>>;
+    readonly activatorRef: Ref<any>;
+    readonly availableEvents: ActivatorEvents;
+    readonly component: ComponentInternalInstance;
+    readonly contentEvents: ComputedRef<Partial<ContentEvents>>;
+    readonly delayClose: () => Promise<boolean>;
+    readonly delayOpen: () => Promise<boolean>;
+    readonly openOnClick: ComputedRef<boolean>;
+    readonly openOnFocus: ComputedRef<boolean>;
+    readonly veilEvents: ComputedRef<Partial<VeilEvents>>;
+    isHovered: boolean;
+    isFocused: boolean;
+    firstEnter: boolean;
+    private watcher?;
+    private scope?;
+    constructor(props: ActivatorProps, isActive: Ref<boolean>, isTopOfStack: Ref<boolean>);
+    /**
+     * ## Create Activator Events
+     * Returns a computed set of partially available events.
+     * @private
+     */
+    private createActivatorEvents;
+    /**
+     * ## Create Content Events
+     * @private
+     */
+    private createContentEvents;
+    /**
+     * ## Create Delay Functions
+     * @private
+     */
+    private createDelayFunctions;
+    /**
+     * ## Create Veil Events
+     * @private
+     */
+    private createVeilEvents;
+    /**
+     *
+     * @param selector
+     * @private
+     */
+    getActivatorEl(selector?: ActivatorSelector | undefined): HTMLElement | undefined;
+    /**
+     * ## Get Available Events
+     */
+    getAvailableEvents(): ActivatorEvents;
+    /**
+     * ## Is Close on Content Click?
+     * Should we close overlays when the content of the overlay is clicked.
+     * For example, when a menu item is clicked.
+     */
+    isCloseOnContentClick(): boolean;
+    /**
+     * ## Is Open On Click?
+     */
+    isOpenOnClick(): boolean;
+    /**
+     * ## Is Open on Hover?
+     */
+    isOpenOnHover(): boolean;
+    /**
+     * ## Is Open on Focus?
+     */
+    isOpenOnFocus(): boolean;
+    /**
+     * ## On Blur
+     * @param e
+     */
+    onBlur(e: FocusEvent): void;
+    /**
+     * ## On Click
+     * @param e
+     */
+    onClick(e: MouseEvent): void;
+    /**
+     * ## On Focus
+     * @param e
+     */
+    onFocus(e: FocusEvent): void;
+    /**
+     * ## On Mouse Enter (Hover)
+     * @param e
+     */
+    onMouseenter(e: UIMouseEvent): void;
+    /**
+     * ## On Mouse Leave
+     * @param e
+     */
+    onMouseleave(e: MouseEvent): void;
+    /**
+     * ## Set Activator Element
+     * @param activator
+     */
+    setActivatorEl(activator?: HTMLElement): HTMLElement | undefined;
+    /**
+     * ## Watch Activator Prop
+     * @private
+     */
+    private watchActivatorProp;
+    /**
+     * ## Watch for changes in `activatorEl`
+     * @private
+     */
+    private watchActivatorEl;
+    /**
+     * ## Watch for changes in `isTopOfStack`.
+     * @private
+     */
+    private watchIsTopOfStack;
+}
+export {};

package/dist/components/EvOverlay/index.d.ts

@@ -0,0 +1,5 @@
+export * from './activator.ts';
+export * from './position.ts';
+export * from './scroll.ts';
+export * from './EvOverlay.ts';
+export { default as EvOverlay } from './EvOverlay.vue';

package/dist/components/EvOverlay/position-strategy/connected-position.d.ts

@@ -0,0 +1,15 @@
+import { StyleProp, Rect } from '../../../util';
+import { Ref } from 'vue';
+import { PositionStrategyData, PositionStrategyProps } from '../position.ts';
+
+/**
+ * # Connected Position Strategy
+ *
+ * Connected to a certain element
+ */
+export declare function connectedPositionStrategy(data: PositionStrategyData, props: PositionStrategyProps, contentStyles: Ref<StyleProp>): {
+    updatePosition: () => {
+        zoneRect: Rect;
+        contentRect: Rect;
+    } | undefined;
+};

package/dist/components/EvOverlay/position-strategy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './connected-position';
+export * from './static-position';

package/dist/components/EvOverlay/position-strategy/static-position.d.ts

@@ -0,0 +1,10 @@
+import { StyleProp } from '../../../util';
+import { Ref } from 'vue';
+import { PositionStrategyData, PositionStrategyProps } from '../position.ts';
+
+/**
+ * # Static Position Strategy
+ *
+ * Specific viewport position, usually centered.
+ */
+export declare function staticPositionStrategy(data: PositionStrategyData, props: PositionStrategyProps, contentStyles: Ref<StyleProp>): void;

package/dist/components/EvOverlay/position.d.ts

@@ -0,0 +1,81 @@
+import { AnchorSelector } from '../../util';
+import { connectedPositionStrategy, staticPositionStrategy } from './position-strategy';
+import { PropType, Ref } from 'vue';
+
+export interface PositionStrategyData {
+    contentEl: Ref<HTMLElement | undefined>;
+    activatorEl: Ref<HTMLElement | undefined>;
+    isActive: Ref<boolean>;
+    isRtl: Ref<boolean>;
+}
+type PositionStrategyFn = (data: PositionStrategyData, props: PositionStrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
+    updatePosition: (e: Event) => void;
+};
+declare const positionStrategies: {
+    static: typeof staticPositionStrategy;
+    connected: typeof connectedPositionStrategy;
+};
+export interface PositionStrategyProps {
+    positionStrategy: keyof typeof positionStrategies | PositionStrategyFn;
+    position: AnchorSelector;
+    origin: AnchorSelector | 'overlap';
+    offset?: number | string | number[];
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+}
+/**
+ * # Make Position Strategy Props
+ */
+export declare const makePositionStrategyProps: <Defaults extends {
+    positionStrategy?: unknown;
+    position?: unknown;
+    origin?: unknown;
+    offset?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    positionStrategy: unknown extends Defaults["positionStrategy"] ? {
+        type: PropType<"static" | "connected" | PositionStrategyFn>;
+        default: string;
+        validator: (value: any) => boolean;
+    } : Omit<{
+        type: PropType<"static" | "connected" | PositionStrategyFn>;
+        default: string;
+        validator: (value: any) => boolean;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["positionStrategy"] ? "static" | "connected" | PositionStrategyFn : NonNullable<"static" | "connected" | PositionStrategyFn> | Defaults["positionStrategy"]>;
+        default: unknown extends Defaults["positionStrategy"] ? "static" | "connected" | PositionStrategyFn : NonNullable<"static" | "connected" | PositionStrategyFn> | Defaults["positionStrategy"];
+    };
+    position: unknown extends Defaults["position"] ? {
+        type: PropType<AnchorSelector>;
+        default: string;
+    } : Omit<{
+        type: PropType<AnchorSelector>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["position"] ? AnchorSelector : NonNullable<AnchorSelector> | Defaults["position"]>;
+        default: unknown extends Defaults["position"] ? AnchorSelector : NonNullable<AnchorSelector> | Defaults["position"];
+    };
+    origin: unknown extends Defaults["origin"] ? {
+        type: PropType<AnchorSelector | "overlap">;
+        default: string;
+    } : Omit<{
+        type: PropType<AnchorSelector | "overlap">;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["origin"] ? AnchorSelector | "overlap" : NonNullable<AnchorSelector | "overlap"> | Defaults["origin"]>;
+        default: unknown extends Defaults["origin"] ? AnchorSelector | "overlap" : NonNullable<AnchorSelector | "overlap"> | Defaults["origin"];
+    };
+    offset: unknown extends Defaults["offset"] ? PropType<string | number | number[] | undefined> : {
+        type: PropType<unknown extends Defaults["offset"] ? string | number | number[] | undefined : NonNullable<string | number | number[] | undefined> | Defaults["offset"]>;
+        default: unknown extends Defaults["offset"] ? string | number | number[] | undefined : NonNullable<string | number | number[] | undefined> | Defaults["offset"];
+    };
+};
+/**
+ * # Use Position Strategies
+ */
+export declare function usePositionStrategies(props: PositionStrategyProps, data: PositionStrategyData): {
+    contentStyles: Ref<{}>;
+    updatePosition: Ref<((e: Event) => void) | undefined>;
+};
+export {};

package/dist/components/EvOverlay/scroll-strategy/block-scroll.d.ts

@@ -0,0 +1,8 @@
+import { ScrollStrategyData, ScrollStrategyProps } from '../scroll.ts';
+
+/**
+ * # Block Scroll Strategy
+ * @param data
+ * @param props
+ */
+export declare function blockScrollStrategy(data: ScrollStrategyData, props: ScrollStrategyProps): void;

package/dist/components/EvOverlay/scroll-strategy/close-scroll.d.ts

@@ -0,0 +1,7 @@
+import { ScrollStrategyData } from '../scroll.ts';
+
+/**
+ * # Close Scroll Strategy
+ * @param data
+ */
+export declare function closeScrollStrategy(data: ScrollStrategyData): void;

package/dist/components/EvOverlay/scroll-strategy/index.d.ts

@@ -0,0 +1,3 @@
+export * from './block-scroll';
+export * from './close-scroll';
+export * from './reposition-scroll';

package/dist/components/EvOverlay/scroll-strategy/reposition-scroll.d.ts

@@ -0,0 +1,10 @@
+import { EffectScope } from 'vue';
+import { ScrollStrategyData, ScrollStrategyProps } from '../scroll.ts';
+
+/**
+ * # Reposition Scroll Strategy
+ * @param data
+ * @param props
+ * @param scope
+ */
+export declare function repositionScrollStrategy(data: ScrollStrategyData, props: ScrollStrategyProps, scope: EffectScope): void;

package/dist/components/EvOverlay/scroll.d.ts

@@ -0,0 +1,47 @@
+import { blockScrollStrategy, closeScrollStrategy, repositionScrollStrategy } from './scroll-strategy';
+import { EffectScope, PropType, Ref } from 'vue';
+
+export interface ScrollStrategyData {
+    containerEl: Ref<HTMLElement | undefined>;
+    contentEl: Ref<HTMLElement | undefined>;
+    activatorEl: Ref<HTMLElement | undefined>;
+    isActive: Ref<boolean>;
+    updatePosition: Ref<((e: Event) => void) | undefined>;
+}
+type ScrollStrategyFn = (data: ScrollStrategyData, props: ScrollStrategyProps, scope: EffectScope) => void;
+declare const scrollStrategies: {
+    none: null;
+    close: typeof closeScrollStrategy;
+    block: typeof blockScrollStrategy;
+    reposition: typeof repositionScrollStrategy;
+};
+export interface ScrollStrategyProps {
+    scrollStrategy: keyof typeof scrollStrategies | ScrollStrategyFn;
+    contained: boolean | undefined;
+}
+/**
+ * # Make Scroll Strategy Props
+ */
+export declare const makeScrollStrategyProps: <Defaults extends {
+    scrollStrategy?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    scrollStrategy: unknown extends Defaults["scrollStrategy"] ? {
+        type: PropType<"none" | "close" | "block" | ScrollStrategyFn | "reposition">;
+        default: string;
+        validator: (val: any) => boolean;
+    } : Omit<{
+        type: PropType<"none" | "close" | "block" | ScrollStrategyFn | "reposition">;
+        default: string;
+        validator: (val: any) => boolean;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["scrollStrategy"] ? "none" | "close" | "block" | ScrollStrategyFn | "reposition" : NonNullable<"none" | "close" | "block" | ScrollStrategyFn | "reposition"> | Defaults["scrollStrategy"]>;
+        default: unknown extends Defaults["scrollStrategy"] ? "none" | "close" | "block" | ScrollStrategyFn | "reposition" : NonNullable<"none" | "close" | "block" | ScrollStrategyFn | "reposition"> | Defaults["scrollStrategy"];
+    };
+};
+/**
+ * # Use Scroll Strategies
+ * @param props
+ * @param data
+ */
+export declare function useScrollStrategies(props: ScrollStrategyProps, data: ScrollStrategyData): void;
+export {};

package/dist/components/EvProgress/EvProgress.vue.d.ts

@@ -0,0 +1,42 @@
+import { AppearanceProp, InputSizeProp } from '../../util';
+
+interface ProgressProps {
+    appearance?: AppearanceProp;
+    indeterminate?: boolean;
+    percentage?: number;
+    size?: InputSizeProp | number;
+}
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ProgressProps>, {
+    appearance: string;
+    indeterminate: boolean;
+    percentage: number;
+    size: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ProgressProps>, {
+    appearance: string;
+    indeterminate: boolean;
+    percentage: number;
+    size: string;
+}>>>, {
+    appearance: "default" | "danger" | "information" | "notice" | "primary" | "success" | "warning";
+    size: number | InputSizeProp;
+    indeterminate: boolean;
+    percentage: number;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/EvProgress/index.d.ts

@@ -0,0 +1 @@
+export { default as EvProgress } from './EvProgress.vue';

package/dist/components/EvProgressCircular/EvProgressCircular.vue.d.ts

@@ -0,0 +1,58 @@
+import { AppearanceProp } from '../../util';
+
+type Size = 'default';
+interface ProgressProps {
+    appearance?: AppearanceProp;
+    indeterminate?: boolean;
+    percentage?: number;
+    rotate?: number;
+    size?: Size | number;
+    thickness?: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ProgressProps>, {
+    appearance: string;
+    size: string;
+    indeterminate: boolean;
+    percentage: number;
+    rotate: number;
+    thickness: number;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ProgressProps>, {
+    appearance: string;
+    size: string;
+    indeterminate: boolean;
+    percentage: number;
+    rotate: number;
+    thickness: number;
+}>>>, {
+    appearance: "default" | "danger" | "information" | "notice" | "primary" | "success" | "warning";
+    size: number | "default";
+    rotate: number;
+    indeterminate: boolean;
+    percentage: number;
+    thickness: number;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/EvProgressCircular/index.d.ts

@@ -0,0 +1 @@
+export { default as EvProgressCircular } from './EvProgressCircular.vue';

package/dist/components/EvQuickfind/EvQuickfind.vue.d.ts

@@ -0,0 +1,35 @@
+
+type QuickfindSize = 'small' | 'medium' | 'large';
+interface QuickfindProps {
+    modelValue?: string | number;
+    bold?: boolean;
+    size?: QuickfindSize;
+}
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<QuickfindProps>, {
+    bold: boolean;
+    size: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<QuickfindProps>, {
+    bold: boolean;
+    size: string;
+}>>>, {
+    bold: boolean;
+    size: QuickfindSize;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/EvQuickfind/index.d.ts

@@ -0,0 +1 @@
+export { default as EvQuickfind } from './EvQuickfind.vue';