@depup/testing-library__user-event 14.6.3-depup.0

package/dist/types/event/selection/resolveCaretPosition.d.ts

@@ -0,0 +1,8 @@
+export declare function resolveCaretPosition({ target, node, offset, }: {
+    target: Element;
+    node?: Node;
+    offset?: number;
+}): {
+    node: Node;
+    offset: number;
+};

package/dist/types/event/selection/selectAll.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Expand a selection like the browser does when pressing Ctrl+A.
+ */
+export declare function selectAll(target: Element): void;
+export declare function isAllSelected(target: Element): boolean;

package/dist/types/event/selection/setSelection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Set the selection
+ */
+export declare function setSelection({ focusNode, focusOffset, anchorNode, anchorOffset, }: {
+    anchorNode?: Node;
+    /** DOM offset */
+    anchorOffset?: number;
+    focusNode: Node;
+    focusOffset: number;
+}): void;

package/dist/types/event/selection/setSelectionPerMouse.d.ts

@@ -0,0 +1,8 @@
+import { type SelectionRange } from '.';
+export declare function setSelectionPerMouseDown({ document, target, clickCount, node, offset, }: {
+    document: Document;
+    target: Element;
+    clickCount: number;
+    node?: Node;
+    offset?: number;
+}): Range | SelectionRange | undefined;

package/dist/types/event/selection/setSelectionRange.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Backward-compatible selection.
+ *
+ * Handles input elements and contenteditable if it only contains a single text node.
+ */
+export declare function setSelectionRange(element: Element, anchorOffset: number, focusOffset: number): void;

package/dist/types/event/selection/updateSelectionOnFocus.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reset the Document Selection when moving focus into an element
+ * with own selection implementation.
+ */
+export declare function updateSelectionOnFocus(element: Element): void;

package/dist/types/event/types.d.ts

@@ -0,0 +1,20 @@
+import { eventMap } from './eventMap';
+export type EventType = keyof typeof eventMap;
+export type EventTypeInit<K extends EventType> = SpecificEventInit<FixedDocumentEventMap[K]>;
+export interface FixedDocumentEventMap extends DocumentEventMap {
+    input: InputEvent;
+}
+type SpecificEventInit<E extends Event> = E extends InputEvent ? InputEventInit : E extends ClipboardEvent ? ClipboardEventInit : E extends KeyboardEvent ? KeyboardEventInit : E extends PointerEvent ? PointerEventInit : E extends MouseEvent ? MouseEventInit : E extends FocusEvent ? FocusEventInit : E extends UIEvent ? UIEventInit : EventInit;
+export interface PointerCoords {
+    x?: number;
+    y?: number;
+    clientX?: number;
+    clientY?: number;
+    offsetX?: number;
+    offsetY?: number;
+    pageX?: number;
+    pageY?: number;
+    screenX?: number;
+    screenY?: number;
+}
+export {};

package/dist/types/event/wrapEvent.d.ts

@@ -0,0 +1 @@
+export declare function wrapEvent<R>(cb: () => R, _element: Element): R;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { userEvent as default } from './setup';
+export { userEvent } from './setup';
+export type { UserEvent } from './setup/setup';
+export type { keyboardKey } from './system/keyboard';
+export type { pointerKey } from './system/pointer';
+export { PointerEventsCheckLevel, type Options } from './options';

package/dist/types/keyboard/index.d.ts

@@ -0,0 +1,3 @@
+import { type Instance } from '../setup';
+export declare function keyboard(this: Instance, text: string): Promise<void>;
+export declare function releaseAllKeys(instance: Instance): Promise<void>;

package/dist/types/keyboard/keyMap.d.ts

@@ -0,0 +1,5 @@
+import { keyboardKey } from '../system/keyboard';
+/**
+ * Mapping for a default US-104-QWERTY keyboard
+ */
+export declare const defaultKeyMap: keyboardKey[];

package/dist/types/keyboard/parseKeyDef.d.ts

@@ -0,0 +1,17 @@
+import { keyboardKey } from '../system/keyboard';
+/**
+ * Parse key definitions per `keyboardMap`
+ *
+ * Keys can be referenced by `{key}` or `{special}` as well as physical locations per `[code]`.
+ * Everything else will be interpreted as a typed character - e.g. `a`.
+ * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
+ * Keeping the key pressed can be written as `{key>}`.
+ * When keeping the key pressed you can choose how long (how many keydown and keypress) the key is pressed `{key>3}`.
+ * You can then release the key per `{key>3/}` or keep it pressed and continue with the next key.
+ */
+export declare function parseKeyDef(keyboardMap: keyboardKey[], text: string): {
+    keyDef: keyboardKey;
+    releasePrevious: boolean;
+    releaseSelf: boolean;
+    repeat: number;
+}[];

package/dist/types/options.d.ts

@@ -0,0 +1,115 @@
+import { type keyboardKey } from './system/keyboard';
+import { type pointerKey } from './system/pointer';
+export declare enum PointerEventsCheckLevel {
+    /**
+     * Check pointer events on every user interaction that triggers a bunch of events.
+     * E.g. once for releasing a mouse button even though this triggers `pointerup`, `mouseup`, `click`, etc...
+     */
+    EachTrigger = 4,
+    /** Check each target once per call to pointer (related) API */
+    EachApiCall = 2,
+    /** Check each event target once */
+    EachTarget = 1,
+    /** No pointer events check */
+    Never = 0
+}
+export interface Options {
+    /**
+     * When using `userEvent.upload`, automatically discard files
+     * that don't match an `accept` property if it exists.
+     *
+     * @default true
+     */
+    applyAccept?: boolean;
+    /**
+     * We intend to automatically apply modifier keys for printable characters in the future.
+     * I.e. `A` implying `{Shift>}a{/Shift}` if caps lock is not active.
+     *
+     * This options allows you to opt out of this change in foresight.
+     * The feature therefore will not constitute a breaking change.
+     *
+     * @default true
+     */
+    autoModify?: boolean;
+    /**
+     * Between some subsequent inputs like typing a series of characters
+     * the code execution is delayed per `setTimeout` for (at least) `delay` milliseconds.
+     * This moves the next changes at least to next macro task
+     * and allows other (asynchronous) code to run between events.
+     *
+     * `null` prevents `setTimeout` from being called.
+     *
+     * @default 0
+     */
+    delay?: number | null;
+    /**
+     * The document.
+     *
+     * This defaults to the owner document of an element if an API is called directly with an element and without setup.
+     * Otherwise it falls back to the global document.
+     *
+     * @default element.ownerDocument??globalThis.document
+     */
+    document?: Document;
+    /**
+     * An array of keyboard keys the keyboard device consists of.
+     *
+     * This allows to plug in different layouts / localizations.
+     *
+     * Defaults to a "standard" US-104-QWERTY keyboard.
+     */
+    keyboardMap?: keyboardKey[];
+    /**
+     * An array of available pointer keys.
+     *
+     * This allows to plug in different pointer devices.
+     */
+    pointerMap?: pointerKey[];
+    /**
+     * The pointer API includes a check if an element has or inherits `pointer-events: none`.
+     * This check is known to be expensive and very expensive when checking deeply nested nodes.
+     * This option determines how often the pointer related APIs perform the check.
+     *
+     * This is a binary flag option. You can combine multiple Levels.
+     *
+     * @default PointerEventsCheckLevel.EachApiCall
+     */
+    pointerEventsCheck?: PointerEventsCheckLevel | number;
+    /**
+     * `userEvent.type` automatically releases any keys still pressed at the end of the call.
+     * This option allows to opt out of this feature.
+     *
+     * @default false
+     */
+    skipAutoClose?: boolean;
+    /**
+     * `userEvent.type` implies a click at the end of the element content/value.
+     * This option allows to opt out of this feature.
+     *
+     * @default false
+     */
+    skipClick?: boolean;
+    /**
+     * `userEvent.click` implies moving the cursor to the target element first.
+     * This options allows to opt out of this feature.
+     *
+     * @default false
+     */
+    skipHover?: boolean;
+    /**
+     * Write selected data to Clipboard API when a `cut` or `copy` is triggered.
+     *
+     * The Clipboard API is usually not available to test code.
+     * Our `setup` replaces the `navigator.clipboard` property with a stub.
+     *
+     * Defaults to `false` when calling the APIs directly.
+     * Defaults to `true` when calling the APIs per `setup`.
+     */
+    writeToClipboard?: boolean;
+    /**
+     * A function to be called internally to advance your fake timers (if applicable)
+     *
+     * @example jest.advanceTimersByTime
+     */
+    advanceTimers?: ((delay: number) => Promise<void>) | ((delay: number) => void);
+}

package/dist/types/pointer/index.d.ts

@@ -0,0 +1,28 @@
+import { type PointerCoords } from '../event';
+import { type Instance } from '../setup';
+import { type pointerKey } from '../system/pointer';
+type PointerActionInput = string | ({
+    keys: string;
+} & PointerActionPosition) | PointerAction;
+export type PointerInput = PointerActionInput | Array<PointerActionInput>;
+type PointerAction = PointerPressAction | PointerMoveAction;
+type PointerActionPosition = {
+    target?: Element;
+    coords?: PointerCoords;
+    node?: Node;
+    /**
+     * If `node` is set, this is the DOM offset.
+     * Otherwise this is the `textContent`/`value` offset on the `target`.
+     */
+    offset?: number;
+};
+interface PointerPressAction extends PointerActionPosition {
+    keyDef: pointerKey;
+    releasePrevious: boolean;
+    releaseSelf: boolean;
+}
+interface PointerMoveAction extends PointerActionPosition {
+    pointerName?: string;
+}
+export declare function pointer(this: Instance, input: PointerInput): Promise<void>;
+export {};

package/dist/types/pointer/keyMap.d.ts

@@ -0,0 +1,2 @@
+import { pointerKey } from '../system/pointer';
+export declare const defaultKeyMap: pointerKey[];

package/dist/types/pointer/parseKeyDef.d.ts

@@ -0,0 +1,6 @@
+import { pointerKey } from '../system/pointer';
+export declare function parseKeyDef(pointerMap: pointerKey[], keys: string): {
+    keyDef: pointerKey;
+    releasePrevious: boolean;
+    releaseSelf: boolean;
+}[];

package/dist/types/setup/api.d.ts

@@ -0,0 +1,23 @@
+import { click, dblClick, tripleClick, hover, unhover, tab } from '../convenience';
+import { keyboard } from '../keyboard';
+import { copy, cut, paste } from '../clipboard';
+import { pointer } from '../pointer';
+import { clear, deselectOptions, selectOptions, type, upload } from '../utility';
+export declare const userEventApi: {
+    click: typeof click;
+    dblClick: typeof dblClick;
+    tripleClick: typeof tripleClick;
+    hover: typeof hover;
+    unhover: typeof unhover;
+    tab: typeof tab;
+    keyboard: typeof keyboard;
+    copy: typeof copy;
+    cut: typeof cut;
+    paste: typeof paste;
+    pointer: typeof pointer;
+    clear: typeof clear;
+    deselectOptions: typeof deselectOptions;
+    selectOptions: typeof selectOptions;
+    type: typeof type;
+    upload: typeof upload;
+};

package/dist/types/setup/directApi.d.ts

@@ -0,0 +1,24 @@
+import { type Options } from '../options';
+import { type PointerInput } from '../pointer';
+import { type System } from '../system';
+import { type UserEventApi } from './setup';
+export type DirectOptions = Options & {
+    keyboardState?: System;
+    pointerState?: System;
+};
+export declare function clear(element: Element): Promise<void>;
+export declare function click(element: Element, options?: DirectOptions): Promise<void>;
+export declare function copy(options?: DirectOptions): Promise<DataTransfer | undefined>;
+export declare function cut(options?: DirectOptions): Promise<DataTransfer | undefined>;
+export declare function dblClick(element: Element, options?: DirectOptions): Promise<void>;
+export declare function deselectOptions(select: Element, values: HTMLElement | HTMLElement[] | string[] | string, options?: DirectOptions): Promise<void>;
+export declare function hover(element: Element, options?: DirectOptions): Promise<void>;
+export declare function keyboard(text: string, options?: DirectOptions): Promise<System>;
+export declare function pointer(input: PointerInput, options?: DirectOptions): Promise<System>;
+export declare function paste(clipboardData?: DataTransfer | string, options?: DirectOptions): Promise<void>;
+export declare function selectOptions(select: Element, values: HTMLElement | HTMLElement[] | string[] | string, options?: DirectOptions): Promise<void>;
+export declare function tripleClick(element: Element, options?: DirectOptions): Promise<void>;
+export declare function type(element: Element, text: string, options?: DirectOptions & Parameters<UserEventApi['type']>[2]): Promise<void>;
+export declare function unhover(element: Element, options?: DirectOptions): Promise<void>;
+export declare function upload(element: HTMLElement, fileOrFiles: File | File[], options?: DirectOptions): Promise<void>;
+export declare function tab(options?: DirectOptions & Parameters<UserEventApi['tab']>[0]): Promise<void>;

package/dist/types/setup/index.d.ts

@@ -0,0 +1,22 @@
+import { setupMain } from './setup';
+import * as directApi from './directApi';
+export type { Instance } from './setup';
+export declare const userEvent: {
+    readonly setup: typeof setupMain;
+    readonly clear: typeof directApi.clear;
+    readonly click: typeof directApi.click;
+    readonly copy: typeof directApi.copy;
+    readonly cut: typeof directApi.cut;
+    readonly dblClick: typeof directApi.dblClick;
+    readonly deselectOptions: typeof directApi.deselectOptions;
+    readonly hover: typeof directApi.hover;
+    readonly keyboard: typeof directApi.keyboard;
+    readonly pointer: typeof directApi.pointer;
+    readonly paste: typeof directApi.paste;
+    readonly selectOptions: typeof directApi.selectOptions;
+    readonly tripleClick: typeof directApi.tripleClick;
+    readonly type: typeof directApi.type;
+    readonly unhover: typeof directApi.unhover;
+    readonly upload: typeof directApi.upload;
+    readonly tab: typeof directApi.tab;
+};

package/dist/types/setup/setup.d.ts

@@ -0,0 +1,44 @@
+import { dispatchEvent, dispatchUIEvent } from '../event';
+import { Options } from '../options';
+import { System } from '../system';
+import { userEventApi } from './api';
+import { DirectOptions } from './directApi';
+export type UserEventApi = typeof userEventApi;
+export type UserEvent = {
+    readonly setup: (...args: Parameters<typeof setupSub>) => UserEvent;
+} & {
+    readonly [k in keyof UserEventApi]: (...args: Parameters<UserEventApi[k]>) => ReturnType<UserEventApi[k]>;
+};
+export type Instance = UserEventApi & {
+    config: Config;
+    dispatchEvent: OmitThisParameter<typeof dispatchEvent>;
+    dispatchUIEvent: OmitThisParameter<typeof dispatchUIEvent>;
+    system: System;
+    levelRefs: Record<number, object | undefined>;
+};
+export type Config = Required<Options>;
+export declare function createConfig(options?: Options, defaults?: Required<Options>, node?: Node): Config;
+/**
+ * Start a "session" with userEvent.
+ * All APIs returned by this function share an input device state and a default configuration.
+ */
+export declare function setupMain(options?: Options): UserEvent;
+/**
+ * Setup in direct call per `userEvent.anyApi()`
+ */
+export declare function setupDirect({ keyboardState, pointerState, ...options }?: DirectOptions & {
+    keyboardState?: System;
+    pointerState?: System;
+}, // backward-compatibility
+node?: Node): {
+    api: UserEvent;
+    system: System;
+};
+/**
+ * Create a set of callbacks with different default settings but the same state.
+ */
+export declare function setupSub(this: Instance, options: Options): UserEvent;
+export declare function createInstance(config: Config, system?: System): {
+    instance: Instance;
+    api: UserEvent;
+};

package/dist/types/setup/wrapAsync.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Wrap an internal Promise
+ */
+export declare function wrapAsync<R, P extends (() => Promise<R>) | (() => R)>(implementation: P): Promise<R>;

package/dist/types/system/index.d.ts

@@ -0,0 +1,10 @@
+import { KeyboardHost } from './keyboard';
+import { PointerHost } from './pointer';
+/**
+ * @internal Do not create/alter this by yourself as this type might be subject to changes.
+ */
+export declare class System {
+    readonly keyboard: KeyboardHost;
+    readonly pointer: PointerHost;
+    getUIEventModifiers(): EventModifierInit;
+}

package/dist/types/system/keyboard.d.ts

@@ -0,0 +1,50 @@
+import { type Instance } from '../setup';
+import { type System } from '.';
+export declare enum DOM_KEY_LOCATION {
+    STANDARD = 0,
+    LEFT = 1,
+    RIGHT = 2,
+    NUMPAD = 3
+}
+export interface keyboardKey {
+    /** Physical location on a keyboard */
+    code?: string;
+    /** Character or functional key descriptor */
+    key?: string;
+    /** Location on the keyboard for keys with multiple representation */
+    location?: DOM_KEY_LOCATION;
+    /** Does the character in `key` require/imply AltRight to be pressed? */
+    altGr?: boolean;
+    /** Does the character in `key` require/imply a shiftKey to be pressed? */
+    shift?: boolean;
+}
+export declare class KeyboardHost {
+    readonly system: System;
+    constructor(system: System);
+    readonly modifiers: {
+        Alt: boolean;
+        AltGraph: boolean;
+        CapsLock: boolean;
+        Control: boolean;
+        Fn: boolean;
+        FnLock: boolean;
+        Meta: boolean;
+        NumLock: boolean;
+        ScrollLock: boolean;
+        Shift: boolean;
+        Symbol: boolean;
+        SymbolLock: boolean;
+    };
+    private readonly pressed;
+    carryChar: string;
+    private lastKeydownTarget;
+    private readonly modifierLockStart;
+    isKeyPressed(keyDef: keyboardKey): boolean;
+    getPressedKeys(): keyboardKey[];
+    /** Press a key */
+    keydown(instance: Instance, keyDef: keyboardKey): Promise<void>;
+    /** Release a key */
+    keyup(instance: Instance, keyDef: keyboardKey): Promise<void>;
+    private setKeydownTarget;
+    private hasKeyPress;
+}

package/dist/types/system/pointer/buttons.d.ts

@@ -0,0 +1,23 @@
+import { type pointerKey } from './shared';
+export declare class Buttons {
+    private readonly pressed;
+    getButtons(): number;
+    down(keyDef: pointerKey): number | undefined;
+    up(keyDef: pointerKey): number | undefined;
+}
+export declare const MouseButton: {
+    readonly primary: 0;
+    readonly secondary: 1;
+    readonly auxiliary: 2;
+    readonly back: 3;
+    readonly X1: 3;
+    readonly forward: 4;
+    readonly X2: 4;
+};
+export type MouseButton = keyof typeof MouseButton | number;
+export declare function getMouseButtonId(button?: MouseButton): number;
+export declare const MouseButtonFlip: {
+    readonly 1: 2;
+    readonly 2: 1;
+};
+export declare function getMouseEventButton(button?: MouseButton): number;

package/dist/types/system/pointer/device.d.ts

@@ -0,0 +1,8 @@
+import { type pointerKey } from '.';
+export declare class Device {
+    private pressedKeys;
+    get countPressed(): number;
+    isPressed(keyDef: pointerKey): boolean;
+    addPressed(keyDef: pointerKey): Set<string>;
+    removePressed(keyDef: pointerKey): boolean;
+}

package/dist/types/system/pointer/index.d.ts

@@ -0,0 +1,21 @@
+import { System } from '..';
+import { Instance } from '../../setup';
+import { pointerKey, PointerPosition } from './shared';
+export type { pointerKey, PointerPosition } from './shared';
+export declare class PointerHost {
+    readonly system: System;
+    constructor(system: System);
+    private readonly mouse;
+    private readonly buttons;
+    private readonly devices;
+    private readonly pointers;
+    isKeyPressed(keyDef: pointerKey): boolean;
+    press(instance: Instance, keyDef: pointerKey, position: PointerPosition): Promise<void>;
+    move(instance: Instance, pointerName: string, position: PointerPosition): Promise<void>;
+    release(instance: Instance, keyDef: pointerKey, position: PointerPosition): Promise<void>;
+    getPointerName(keyDef: pointerKey): string;
+    getPreviousPosition(pointerName: string): PointerPosition | undefined;
+    resetClickCount(): void;
+    getMouseTarget(instance: Instance): Element;
+    setMousePosition(position: PointerPosition): void;
+}

package/dist/types/system/pointer/mouse.d.ts

@@ -0,0 +1,31 @@
+import { type Instance } from '../../setup';
+import { pointerKey, PointerPosition } from './shared';
+/**
+ * This object is the single "virtual" mouse that might be controlled by multiple different pointer devices.
+ */
+export declare class Mouse {
+    position: PointerPosition;
+    private readonly buttons;
+    private selecting?;
+    private buttonDownTarget;
+    private readonly clickCount;
+    move(instance: Instance, position: PointerPosition, 
+    /** Whether `preventDefault()` has been called on the `pointerdown` event */
+    isPrevented: boolean): {
+        leave: () => void;
+        enter: () => void;
+        move: () => void;
+    } | undefined;
+    down(instance: Instance, keyDef: pointerKey, 
+    /** Whether `preventDefault()` has been called on the `pointerdown` event */
+    isPrevented: boolean): void;
+    up(instance: Instance, keyDef: pointerKey, 
+    /** Whether `preventDefault()` has been called on the `pointerdown` event */
+    isPrevented: boolean): void;
+    resetClickCount(): void;
+    private getEventInit;
+    private getTarget;
+    private startSelecting;
+    private modifySelecting;
+    private endSelecting;
+}

package/dist/types/system/pointer/pointer.d.ts

@@ -0,0 +1,32 @@
+import { type Instance } from '../../setup';
+import { PointerPosition } from './shared';
+import { Buttons, MouseButton } from './buttons';
+type PointerInit = {
+    pointerId: number;
+    pointerType: string;
+    isPrimary: boolean;
+};
+export declare class Pointer {
+    constructor({ pointerId, pointerType, isPrimary }: PointerInit, buttons: Buttons);
+    readonly pointerId: number;
+    readonly pointerType: string;
+    readonly isPrimary: boolean;
+    readonly buttons: Buttons;
+    isMultitouch: boolean;
+    isCancelled: boolean;
+    isDown: boolean;
+    isPrevented: boolean;
+    position: PointerPosition;
+    init(instance: Instance): this;
+    move(instance: Instance, position: PointerPosition): {
+        leave: () => void;
+        enter: () => void;
+        move: () => void;
+    } | undefined;
+    down(instance: Instance, button?: MouseButton): void;
+    up(instance: Instance, button?: MouseButton): void;
+    release(instance: Instance): void;
+    private getTarget;
+    private getEventInit;
+}
+export {};

package/dist/types/system/pointer/shared.d.ts

@@ -0,0 +1,20 @@
+import { PointerCoords } from '../../event';
+import { MouseButton } from './buttons';
+export interface pointerKey {
+    /** Name of the pointer key */
+    name: string;
+    /** Type of the pointer device */
+    pointerType: 'mouse' | 'pen' | 'touch';
+    /** Type of button */
+    button?: MouseButton;
+}
+export interface PointerPosition {
+    target?: Element;
+    coords?: PointerCoords;
+    caret?: CaretPosition;
+}
+export interface CaretPosition {
+    node?: Node;
+    offset?: number;
+}
+export declare function isDifferentPointerPosition(positionA: PointerPosition, positionB: PointerPosition): boolean;

package/dist/types/utility/clear.d.ts

@@ -0,0 +1,2 @@
+import { type Instance } from '../setup';
+export declare function clear(this: Instance, element: Element): Promise<void>;

package/dist/types/utility/index.d.ts

@@ -0,0 +1,4 @@
+export * from './clear';
+export * from './selectOptions';
+export * from './type';
+export * from './upload';

package/dist/types/utility/selectOptions.d.ts

@@ -0,0 +1,3 @@
+import { type Instance } from '../setup';
+export declare function selectOptions(this: Instance, select: Element, values: HTMLElement | HTMLElement[] | string[] | string): Promise<void>;
+export declare function deselectOptions(this: Instance, select: Element, values: HTMLElement | HTMLElement[] | string[] | string): Promise<void>;

package/dist/types/utility/type.d.ts

@@ -0,0 +1,9 @@
+import { type Instance } from '../setup';
+import { type Options } from '../options';
+export interface typeOptions {
+    skipClick?: Options['skipClick'];
+    skipAutoClose?: Options['skipAutoClose'];
+    initialSelectionStart?: number;
+    initialSelectionEnd?: number;
+}
+export declare function type(this: Instance, element: Element, text: string, { skipClick, skipAutoClose, initialSelectionStart, initialSelectionEnd, }?: typeOptions): Promise<void>;

package/dist/types/utility/upload.d.ts

@@ -0,0 +1,5 @@
+import { type Instance } from '../setup';
+export interface uploadInit {
+    changeInit?: EventInit;
+}
+export declare function upload(this: Instance, element: HTMLElement, fileOrFiles: File | File[]): Promise<void>;

package/dist/types/utils/click/isClickableInput.d.ts

@@ -0,0 +1,15 @@
+declare enum clickableInputTypes {
+    'button' = "button",
+    'color' = "color",
+    'file' = "file",
+    'image' = "image",
+    'reset' = "reset",
+    'submit' = "submit",
+    'checkbox' = "checkbox",
+    'radio' = "radio"
+}
+export type ClickableInputOrButton = HTMLButtonElement | (HTMLInputElement & {
+    type: clickableInputTypes;
+});
+export declare function isClickableInput(element: Element): element is ClickableInputOrButton;
+export {};

package/dist/types/utils/dataTransfer/Blob.d.ts

@@ -0,0 +1,3 @@
+export declare function readBlobText(blob: Blob, FileReader: {
+    new (): FileReader;
+}): Promise<string>;