cypress 10.11.0 → 11.0.1

package/vue/dist/@vue/test-utils/createDomEvent.d.ts

@@ -1,9 +0,0 @@
-import { DomEventNameWithModifier, KeyName, keyCodesByKeyName } from './constants/dom-events';
-interface TriggerOptions {
-    code?: String;
-    key?: String;
-    keyCode?: Number;
-    [custom: string]: any;
-}
-declare function createDOMEvent(eventString: DomEventNameWithModifier | string, options?: TriggerOptions): Event & TriggerOptions;
-export { TriggerOptions, createDOMEvent, keyCodesByKeyName, KeyName };

package/vue/dist/@vue/test-utils/domWrapper.d.ts

@@ -1,18 +0,0 @@
-import BaseWrapper from './baseWrapper';
-import { RefSelector } from './types';
-export declare class DOMWrapper<NodeType extends Node> extends BaseWrapper<NodeType> {
-    constructor(element: NodeType);
-    getRootNodes(): import("./types").VueNode<NodeType>[];
-    getCurrentComponent(): import("vue").ComponentInternalInstance | undefined;
-    find<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>;
-    find<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>;
-    find<T extends Element = Element>(selector: string): DOMWrapper<T>;
-    find<T extends Node = Node>(selector: string | RefSelector): DOMWrapper<T>;
-    findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
-    findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
-    findAll<T extends Element>(selector: string): DOMWrapper<T>[];
-    findAllComponents(selector: any): any;
-    private setChecked;
-    setValue(value?: any): Promise<void>;
-    private setSelected;
-}

package/vue/dist/@vue/test-utils/emit.d.ts

@@ -1,5 +0,0 @@
-import { ComponentPublicInstance, ComponentInternalInstance } from 'vue';
-export declare function emitted<T = unknown>(vm: ComponentPublicInstance, eventName?: string): undefined | T[] | Record<string, T[]>;
-export declare const attachEmitListener: () => void;
-export declare const recordEvent: (vm: ComponentInternalInstance, event: string, args: unknown[]) => void;
-export declare const removeEventHistory: (vm: ComponentPublicInstance) => void;

package/vue/dist/@vue/test-utils/errorWrapper.d.ts

@@ -1 +0,0 @@
-export declare function createWrapperError<T extends object>(wrapperType: 'DOMWrapper' | 'VueWrapper'): T;

package/vue/dist/@vue/test-utils/index.d.ts

@@ -1,11 +0,0 @@
-import { DOMWrapper } from './domWrapper';
-import { VueWrapper } from './vueWrapper';
-import BaseWrapper from './baseWrapper';
-import { mount, shallowMount } from './mount';
-import { MountingOptions } from './types';
-import { RouterLinkStub } from './components/RouterLinkStub';
-import { createWrapperError } from './errorWrapper';
-import { config } from './config';
-import { flushPromises } from './utils/flushPromises';
-import { enableAutoUnmount, disableAutoUnmount } from './utils/autoUnmount';
-export { mount, shallowMount, enableAutoUnmount, disableAutoUnmount, RouterLinkStub, VueWrapper, DOMWrapper, BaseWrapper, config, flushPromises, MountingOptions, createWrapperError };

package/vue/dist/@vue/test-utils/interfaces/wrapperLike.d.ts

@@ -1,56 +0,0 @@
-import { DomEventNameWithModifier } from '../constants/dom-events';
-import { TriggerOptions } from '../createDomEvent';
-import { DefinedComponent, FindAllComponentsSelector, FindComponentSelector, NameSelector, RefSelector } from '../types';
-import { VueWrapper } from '../vueWrapper';
-import { ComponentPublicInstance, FunctionalComponent } from 'vue';
-import type { DOMWrapper } from '../domWrapper';
-export default interface WrapperLike {
-    readonly element: Node;
-    find<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>;
-    find<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>;
-    find<T extends Element = Element>(selector: string): DOMWrapper<T>;
-    find<T extends Node = Node>(selector: string | RefSelector): DOMWrapper<T>;
-    findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
-    findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
-    findAll<T extends Element>(selector: string): DOMWrapper<T>[];
-    findAll(selector: string): DOMWrapper<Element>[];
-    findComponent<T extends never>(selector: string): WrapperLike;
-    findComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>;
-    findComponent<T extends FunctionalComponent>(selector: T | string): DOMWrapper<Element>;
-    findComponent<T extends never>(selector: NameSelector | RefSelector): VueWrapper;
-    findComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): VueWrapper<T>;
-    findComponent(selector: FindComponentSelector): WrapperLike;
-    findAllComponents<T extends never>(selector: string): WrapperLike[];
-    findAllComponents<T extends DefinedComponent>(selector: T | Exclude<FindAllComponentsSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>[];
-    findAllComponents<T extends FunctionalComponent>(selector: string): DOMWrapper<Element>[];
-    findAllComponents<T extends FunctionalComponent>(selector: T): DOMWrapper<Node>[];
-    findAllComponents<T extends never>(selector: NameSelector): VueWrapper[];
-    findAllComponents<T extends ComponentPublicInstance>(selector: T | FindAllComponentsSelector): VueWrapper<T>[];
-    findAllComponents(selector: FindAllComponentsSelector): WrapperLike[];
-    get<K extends keyof HTMLElementTagNameMap>(selector: K): Omit<DOMWrapper<HTMLElementTagNameMap[K]>, 'exists'>;
-    get<K extends keyof SVGElementTagNameMap>(selector: K): Omit<DOMWrapper<SVGElementTagNameMap[K]>, 'exists'>;
-    get<T extends Element = Element>(selector: string): Omit<DOMWrapper<T>, 'exists'>;
-    get<T extends Node = Node>(selector: string | RefSelector): Omit<DOMWrapper<T>, 'exists'>;
-    getComponent<T extends never>(selector: string): Omit<WrapperLike, 'exists'>;
-    getComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): Omit<VueWrapper<InstanceType<T>>, 'exists'>;
-    getComponent<T extends FunctionalComponent>(selector: T | string): Omit<DOMWrapper<Element>, 'exists'>;
-    getComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): Omit<VueWrapper<T>, 'exists'>;
-    getComponent<T extends never>(selector: FindComponentSelector): Omit<WrapperLike, 'exists'>;
-    html(): string;
-    classes(): string[];
-    classes(className: string): boolean;
-    classes(className?: string): string[] | boolean;
-    attributes(): {
-        [key: string]: string;
-    };
-    attributes(key: string): string | undefined;
-    attributes(key?: string): {
-        [key: string]: string;
-    } | string | undefined;
-    text(): string;
-    exists(): boolean;
-    setValue(value: any): Promise<void>;
-    isVisible(): boolean;
-    trigger(eventString: DomEventNameWithModifier, options?: TriggerOptions): Promise<void>;
-    trigger(eventString: string, options?: TriggerOptions): Promise<void>;
-}

package/vue/dist/@vue/test-utils/mount.d.ts

@@ -1,35 +0,0 @@
-import { FunctionalComponent, ComponentPublicInstance, ComponentOptionsWithObjectProps, ComponentOptionsWithArrayProps, ComponentOptionsWithoutProps, ExtractPropTypes, VNodeProps, ComponentOptionsMixin, DefineComponent, MethodOptions, AllowedComponentProps, ComponentCustomProps, ExtractDefaultPropTypes, EmitsOptions, ComputedOptions, ComponentPropsOptions, Prop } from 'vue';
-import { MountingOptions } from './types';
-import { VueWrapper } from './vueWrapper';
-declare type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
-declare type ComponentMountingOptions<T> = T extends DefineComponent<infer PropsOrPropOptions, any, infer D, any, any> ? MountingOptions<Partial<ExtractDefaultPropTypes<PropsOrPropOptions>> & Omit<Readonly<ExtractPropTypes<PropsOrPropOptions>> & PublicProps, keyof ExtractDefaultPropTypes<PropsOrPropOptions>>, D> & Record<string, any> : MountingOptions<any>;
-export declare function mount<V>(originalComponent: {
-    new (...args: any[]): V;
-    __vccOpts: any;
-}, options?: MountingOptions<any> & Record<string, any>): VueWrapper<ComponentPublicInstance<V>>;
-export declare function mount<V, P>(originalComponent: {
-    new (...args: any[]): V;
-    __vccOpts: any;
-    defaultProps?: Record<string, Prop<any>> | string[];
-}, options?: MountingOptions<P & PublicProps> & Record<string, any>): VueWrapper<ComponentPublicInstance<V>>;
-export declare function mount<V>(originalComponent: {
-    new (...args: any[]): V;
-    registerHooks(keys: string[]): void;
-}, options?: MountingOptions<any> & Record<string, any>): VueWrapper<ComponentPublicInstance<V>>;
-export declare function mount<V, P>(originalComponent: {
-    new (...args: any[]): V;
-    props(Props: P): any;
-    registerHooks(keys: string[]): void;
-}, options?: MountingOptions<P & PublicProps> & Record<string, any>): VueWrapper<ComponentPublicInstance<V>>;
-export declare function mount<Props, E extends EmitsOptions = {}>(originalComponent: FunctionalComponent<Props, E>, options?: MountingOptions<Props & PublicProps> & Record<string, any>): VueWrapper<ComponentPublicInstance<Props>>;
-export declare function mount<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = Record<string, any>, EE extends string = string, PP = PublicProps, Props = Readonly<ExtractPropTypes<PropsOrPropOptions>>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>>(component: DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, PP, Props, Defaults>, options?: MountingOptions<Partial<Defaults> & Omit<Props & PublicProps, keyof Defaults>, D> & Record<string, any>): VueWrapper<InstanceType<DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, PP, Props, Defaults>>>;
-export declare function mount<T extends DefineComponent<any, any, any, any>>(component: T, options?: ComponentMountingOptions<T>): VueWrapper<InstanceType<T>>;
-export declare function mount<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends Record<string, Function> = {}, E extends EmitsOptions = Record<string, any>, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, EE extends string = string>(componentOptions: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, E, Mixin, Extends, EE>, options?: MountingOptions<Props & PublicProps, D>): VueWrapper<ComponentPublicInstance<Props, RawBindings, D, C, M, E, VNodeProps & Props>> & Record<string, any>;
-export declare function mount<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends Record<string, Function> = {}, E extends EmitsOptions = Record<string, any>, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, EE extends string = string, Props extends Readonly<{
-    [key in PropNames]?: any;
-}> = Readonly<{
-    [key in PropNames]?: any;
-}>>(componentOptions: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, E, Mixin, Extends, EE, Props>, options?: MountingOptions<Props & PublicProps, D>): VueWrapper<ComponentPublicInstance<Props, RawBindings, D, C, M, E>>;
-export declare function mount<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends Record<string, Function> = {}, E extends EmitsOptions = Record<string, any>, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, EE extends string = string>(componentOptions: ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, E, Mixin, Extends, EE>, options?: MountingOptions<ExtractPropTypes<PropsOptions> & PublicProps, D>): VueWrapper<ComponentPublicInstance<ExtractPropTypes<PropsOptions>, RawBindings, D, C, M, E, VNodeProps & ExtractPropTypes<PropsOptions>>>;
-export declare const shallowMount: typeof mount;
-export {};

package/vue/dist/@vue/test-utils/stubs.d.ts

@@ -1,22 +0,0 @@
-import { VNodeTypes, ConcreteComponent, DefineComponent } from 'vue';
-import { Stubs } from './types';
-export declare type CustomCreateStub = (params: {
-    name: string;
-    component: ConcreteComponent;
-}) => ConcreteComponent;
-interface StubOptions {
-    name: string;
-    type?: ConcreteComponent;
-    renderStubDefaultSlot?: boolean;
-}
-export declare const registerStub: ({ source, stub, originalStub }: {
-    source: ConcreteComponent;
-    stub: ConcreteComponent;
-    originalStub?: ConcreteComponent<{}, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
-}) => void;
-export declare const getOriginalVNodeTypeFromStub: (type: ConcreteComponent) => VNodeTypes | undefined;
-export declare const getOriginalStubFromSpecializedStub: (type: ConcreteComponent) => VNodeTypes | undefined;
-export declare const addToDoNotStubComponents: (type: ConcreteComponent) => WeakSet<ConcreteComponent<{}, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
-export declare const createStub: ({ name, type, renderStubDefaultSlot }: StubOptions) => DefineComponent;
-export declare function stubComponents(stubs?: Stubs, shallow?: boolean, renderStubDefaultSlot?: boolean): void;
-export {};

package/vue/dist/@vue/test-utils/types.d.ts

@@ -1,125 +0,0 @@
-import { Component, ComponentOptions, Directive, Plugin, AppConfig, VNode, VNodeProps, FunctionalComponent, ComponentInternalInstance } from 'vue';
-export interface RefSelector {
-    ref: string;
-}
-export interface NameSelector {
-    name: string;
-    length?: never;
-}
-export declare type FindAllComponentsSelector = DefinedComponent | FunctionalComponent | ComponentOptions | NameSelector | string;
-export declare type FindComponentSelector = RefSelector | FindAllComponentsSelector;
-export declare type Slot = VNode | string | {
-    render: Function;
-} | Function | Component;
-declare type SlotDictionary = {
-    [key: string]: Slot;
-};
-declare type RawProps = VNodeProps & {
-    __v_isVNode?: never;
-    [Symbol.iterator]?: never;
-} & Record<string, any>;
-export interface MountingOptions<Props, Data = {}> {
-    /**
-     * Overrides component's default data. Must be a function.
-     * @see https://next.vue-test-utils.vuejs.org/api/#data
-     */
-    data?: () => {} extends Data ? any : Data extends object ? Partial<Data> : any;
-    /**
-     * Sets component props when mounted.
-     * @see https://next.vue-test-utils.vuejs.org/api/#props
-     */
-    props?: (RawProps & Props) | ({} extends Props ? null : never);
-    /**
-     * @deprecated use `data` instead.
-     */
-    propsData?: Props;
-    /**
-     * Sets component attributes when mounted.
-     * @see https://next.vue-test-utils.vuejs.org/api/#attrs
-     */
-    attrs?: Record<string, unknown>;
-    /**
-     * Provide values for slots on a component.
-     * @see https://next.vue-test-utils.vuejs.org/api/#slots
-     */
-    slots?: SlotDictionary & {
-        default?: Slot;
-    };
-    /**
-     * Provides global mounting options to the component.
-     */
-    global?: GlobalMountOptions;
-    /**
-     * Specify where to mount the component.
-     * Can be a valid CSS selector, or an Element connected to the document.
-     * @see https://next.vue-test-utils.vuejs.org/api/#attachto
-     */
-    attachTo?: HTMLElement | string;
-    /**
-     * Automatically stub out all the child components.
-     * @default false
-     * @see https://next.vue-test-utils.vuejs.org/api/#slots
-     */
-    shallow?: boolean;
-}
-export declare type Stub = boolean | Component;
-export declare type Stubs = Record<string, Stub> | Array<string>;
-export declare type GlobalMountOptions = {
-    /**
-     * Installs plugins on the component.
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-plugins
-     */
-    plugins?: (Plugin | [Plugin, ...any[]])[];
-    /**
-     * Customizes Vue application global configuration
-     * @see https://v3.vuejs.org/api/application-config.html#application-config
-     */
-    config?: Partial<Omit<AppConfig, 'isNativeTag'>>;
-    /**
-     * Applies a mixin for components under testing.
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-mixins
-     */
-    mixins?: ComponentOptions[];
-    /**
-     * Mocks a global instance property.
-     * This is designed to mock variables injected by third party plugins, not
-     * Vue's native properties such as $root, $children, etc.
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-mocks
-     */
-    mocks?: Record<string, any>;
-    /**
-     * Provides data to be received in a setup function via `inject`.
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-provide
-     */
-    provide?: Record<any, any>;
-    /**
-     * Registers components globally for components under testing.
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-components
-     */
-    components?: Record<string, Component | object>;
-    /**
-     * Registers a directive globally for components under testing
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-directives
-     */
-    directives?: Record<string, Directive>;
-    /**
-     * Stubs a component for components under testing.
-     * @default "{ transition: true, 'transition-group': true }"
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-stubs
-     */
-    stubs?: Stubs;
-    /**
-     * Allows rendering the default slot content, even when using
-     * `shallow` or `shallowMount`.
-     * @default false
-     * @see https://next.vue-test-utils.vuejs.org/api/#global-renderstubdefaultslot
-     */
-    renderStubDefaultSlot?: boolean;
-};
-export declare type VueNode<T extends Node = Node> = T & {
-    __vue_app__?: any;
-    __vueParentComponent?: ComponentInternalInstance;
-};
-export declare type VueElement = VueNode<Element>;
-export declare type DefinedComponent = new (...args: any[]) => any;
-export {};

package/vue/dist/@vue/test-utils/utils/autoUnmount.d.ts

@@ -1,5 +0,0 @@
-import { ComponentPublicInstance } from 'vue';
-import type { VueWrapper } from '../vueWrapper';
-export declare function disableAutoUnmount(): void;
-export declare function enableAutoUnmount(hook: Function): void;
-export declare function trackInstance(wrapper: VueWrapper<ComponentPublicInstance>): void;

package/vue/dist/@vue/test-utils/utils/compileSlots.d.ts

@@ -1,2 +0,0 @@
-import * as vue from 'vue';
-export declare function processSlot(source?: string, Vue?: typeof vue): (ctx?: {}) => any;

package/vue/dist/@vue/test-utils/utils/componentName.d.ts

@@ -1,4 +0,0 @@
-import { ComponentInternalInstance } from '@vue/runtime-core';
-import { VNodeTypes } from 'vue';
-export declare const getComponentRegisteredName: (instance: ComponentInternalInstance | null, type: VNodeTypes) => string | null;
-export declare const getComponentName: (instance: any | null, type: VNodeTypes) => string;

package/vue/dist/@vue/test-utils/utils/find.d.ts

@@ -1,10 +0,0 @@
-import { ComponentInternalInstance, VNode } from 'vue';
-import { FindAllComponentsSelector } from '../types';
-/**
- * Detect whether a selector matches a VNode
- * @param node
- * @param selector
- * @return {boolean | ((value: any) => boolean)}
- */
-export declare function matches(node: VNode, rawSelector: FindAllComponentsSelector): boolean;
-export declare function find(root: VNode, selector: FindAllComponentsSelector): ComponentInternalInstance[];

package/vue/dist/@vue/test-utils/utils/flushPromises.d.ts

@@ -1 +0,0 @@
-export declare function flushPromises(): Promise<unknown>;

package/vue/dist/@vue/test-utils/utils/getRootNodes.d.ts

@@ -1,2 +0,0 @@
-import { VNode } from 'vue';
-export declare function getRootNodes(vnode: VNode): Node[];

package/vue/dist/@vue/test-utils/utils/isElement.d.ts

@@ -1 +0,0 @@
-export declare function isElement(element: Node): element is Element;

package/vue/dist/@vue/test-utils/utils/isElementVisible.d.ts

@@ -1,6 +0,0 @@
-/*!
- * isElementVisible
- * Adapted from https://github.com/testing-library/jest-dom
- * Licensed under the MIT License.
- */
-export declare function isElementVisible<T extends Element>(element: T): boolean;

package/vue/dist/@vue/test-utils/utils/matchName.d.ts

@@ -1 +0,0 @@
-export declare function matchName(target: string, sourceName: string): boolean;

package/vue/dist/@vue/test-utils/utils/stringifyNode.d.ts

@@ -1 +0,0 @@
-export declare function stringifyNode(node: Node): string;

package/vue/dist/@vue/test-utils/utils/vueCompatSupport.d.ts

@@ -1,8 +0,0 @@
-import type { ComponentOptions } from 'vue';
-export declare function isLegacyExtendedComponent(component: unknown): component is {
-    (): Function;
-    super: Function;
-    options: ComponentOptions;
-};
-export declare function unwrapLegacyVueExtendComponent<T>(selector: T): T | ComponentOptions;
-export declare function isLegacyFunctionalComponent(component: unknown): boolean;

package/vue/dist/@vue/test-utils/utils/vueShared.d.ts

@@ -1,3 +0,0 @@
-export declare const camelize: (str: string) => string;
-export declare const capitalize: (str: string) => string;
-export declare const hyphenate: (str: string) => string;

package/vue/dist/@vue/test-utils/utils.d.ts

@@ -1,13 +0,0 @@
-import { GlobalMountOptions, RefSelector } from './types';
-import { ComponentOptions, ConcreteComponent, FunctionalComponent } from 'vue';
-export declare function mergeGlobalProperties(mountGlobal?: GlobalMountOptions): Required<GlobalMountOptions>;
-export declare const isObject: (obj: unknown) => obj is Record<string, any>;
-export declare const mergeDeep: (target: Record<string, unknown>, source: Record<string, unknown>) => Record<string, any>;
-export declare function isClassComponent(component: unknown): boolean;
-export declare function isComponent(component: unknown): component is ConcreteComponent;
-export declare function isFunctionalComponent(component: unknown): component is FunctionalComponent;
-export declare function isObjectComponent(component: unknown): component is ComponentOptions;
-export declare function textContent(element: Node): string;
-export declare function hasOwnProperty<O extends {}, P extends PropertyKey>(obj: O, prop: P): obj is O & Record<P, unknown>;
-export declare function isNotNullOrUndefined<T extends {}>(obj: T | null | undefined): obj is T;
-export declare function isRefSelector(selector: string | RefSelector): selector is RefSelector;

package/vue/dist/@vue/test-utils/vueWrapper.d.ts

@@ -1,35 +0,0 @@
-import { App, ComponentCustomProperties, ComponentPublicInstance } from 'vue';
-import { VueNode } from './types';
-import BaseWrapper from './baseWrapper';
-import type { DOMWrapper } from './domWrapper';
-export declare class VueWrapper<T extends Omit<ComponentPublicInstance, '$emit' | keyof ComponentCustomProperties> & {
-    $emit: (event: any, ...args: any[]) => void;
-} & ComponentCustomProperties = ComponentPublicInstance> extends BaseWrapper<Node> {
-    private componentVM;
-    private rootVM;
-    private __app;
-    private __setProps;
-    constructor(app: App | null, vm: T, setProps?: (props: Record<string, unknown>) => void);
-    private get hasMultipleRoots();
-    protected getRootNodes(): VueNode[];
-    private get parentElement();
-    getCurrentComponent(): import("vue").ComponentInternalInstance;
-    exists(): boolean;
-    findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
-    findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
-    findAll<T extends Element>(selector: string): DOMWrapper<T>[];
-    private attachNativeEventListener;
-    get element(): Element;
-    get vm(): T;
-    props(): {
-        [key: string]: any;
-    };
-    props(selector: string): any;
-    emitted<T = unknown>(): Record<string, T[]>;
-    emitted<T = unknown[]>(eventName: string): undefined | T[];
-    isVisible(): boolean;
-    setData(data: Record<string, unknown>): Promise<void>;
-    setProps(props: Record<string, unknown>): Promise<void>;
-    setValue(value: unknown, prop?: string): Promise<void>;
-    unmount(): void;
-}

package/vue/dist/@vue/test-utils/wrapperFactory.d.ts

@@ -1,14 +0,0 @@
-import { ComponentPublicInstance, App } from 'vue';
-import type { DOMWrapper as DOMWrapperType } from './domWrapper';
-import type { VueWrapper as VueWrapperType } from './vueWrapper';
-export declare enum WrapperType {
-    DOMWrapper = 0,
-    VueWrapper = 1
-}
-declare type DOMWrapperFactory = <T extends Node>(element: T) => DOMWrapperType<T>;
-declare type VueWrapperFactory = <T extends ComponentPublicInstance>(app: App | null, vm: T, setProps?: (props: Record<string, unknown>) => Promise<void>) => VueWrapperType<T>;
-export declare function registerFactory(type: WrapperType.DOMWrapper, fn: DOMWrapperFactory): void;
-export declare function registerFactory(type: WrapperType.VueWrapper, fn: VueWrapperFactory): void;
-export declare const createDOMWrapper: DOMWrapperFactory;
-export declare const createVueWrapper: VueWrapperFactory;
-export {};