cypress 10.2.0 → 10.4.0

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,5 @@
+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

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

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,10 @@
+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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+/*!
+ * 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

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

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

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

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,14 @@
+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 {};