webdriverio

const buttonValue: readonly [0, 1, 2, 'left', 'middle', 'right'];

const Key: {
    readonly Ctrl: 'WDIO_CONTROL';
    readonly NULL: '';
    readonly Cancel: '';
    readonly Help: '';
    readonly Backspace: '';
    readonly Tab: '';
    readonly Clear: '';
    readonly Return: '';
    readonly Enter: '';
    readonly Shift: '';
    readonly Control: '';
    readonly Alt: '';
    readonly Pause: '';
    readonly Escape: '';
    readonly Space: '';
    readonly PageUp: '';
    readonly PageDown: '';
    readonly End: '';
    readonly Home: '';
    readonly ArrowLeft: '';
    readonly ArrowUp: '';
    readonly ArrowRight: '';
    readonly ArrowDown: '';
    readonly Insert: '';
    readonly Delete: '';
    readonly Semicolon: '';
    readonly Equals: '';
    readonly Numpad0: '';
    readonly Numpad1: '';
    readonly Numpad2: '';
    readonly Numpad3: '';
    readonly Numpad4: '';
    readonly Numpad5: '';
    readonly Numpad6: '';
    readonly Numpad7: '';
    readonly Numpad8: '';
    readonly Numpad9: '';
    readonly Multiply: '';
    readonly Add: '';
    readonly Separator: '';
    readonly Subtract: '';
    readonly Decimal: '';
    readonly Divide: '';
    readonly F1: '';
    readonly F2: '';
    readonly F3: '';
    readonly F4: '';
    readonly F5: '';
    readonly F6: '';
    readonly F7: '';
    readonly F8: '';
    readonly F9: '';
    readonly F10: '';
    readonly F11: '';
    readonly F12: '';
    readonly Command: '';
    readonly ZenkakuHankaku: '';
};

const SevereServiceError: typeof SevereServiceErrorImport;

attach: (attachOptions: AttachOptions) => Promise<WebdriverIO.Browser>;

multiremote: (
    params: Capabilities.RequestedMultiremoteCapabilities,
    { automationProtocol }?: { automationProtocol?: string }
) => Promise<WebdriverIO.MultiRemoteBrowser>;

remote: (
    params: Capabilities.WebdriverIOConfig,
    remoteModifier?: (
        client: WebDriverTypes.Client,
        options: Capabilities.WebdriverIOConfig
    ) => WebDriverTypes.Client
) => Promise<WebdriverIO.Browser>;

type ActionType = 'key' | 'pointer' | 'wheel';

type ActionTypes = 'press' | 'longPress' | 'tap' | 'moveTo' | 'wait' | 'release';

type AddCommandFn = (...args: any[]) => any;

type BrowserCommandsType = Omit<$BrowserCommands, keyof ChainablePrototype> &
    ChainablePrototype;

type Button = 0 | 1 | 2;

type ButtonNames = 'left' | 'middle' | 'right';

type ClickOptions = LongPressOptions & {
    button: Button | ButtonNames;
    skipRelease: boolean;
};

type CustomLocatorReturnValue =
    | HTMLElement
    | HTMLElement[]
    | NodeListOf<HTMLElement>;

type CustomStrategyFunction = (
    ...args: any
) => ElementReference | ElementReference[];

type CustomStrategyReference = {
    strategy: CustomStrategyFunction;
    strategyName: string;
    strategyArguments: any[];
};

type DragAndDropCoordinate = {
    x: number;
    y: number;
};

type DragAndDropOptions = {
    duration?: number;
};

type ElementArray = ElementArrayExport;

type ElementCommandsType = Omit<$ElementCommands, keyof ChainablePrototype> &
    ChainablePrototype;

type ElementFunction =
    | ((elem: HTMLElement) => HTMLElement | undefined)
    | ((elem: HTMLElement) => (HTMLElement | undefined)[]);

type KeyActionType = 'mouse' | 'pen' | 'touch';

type LongPressOptions = {
    x: number;
    y: number;
    duration: number;
};

type Matcher = {
    name: string;
    args: Array<string | object>;
    class?: string;
};

type MobileScrollIntoViewOptions = SwipeOptions & {
    maxScrolls?: number;
};

type MockFilterOptions = {
    method?: string | ((method: string) => boolean);
    requestHeaders?:
        | Record<string, string>
        | ((headers: Record<string, string>) => boolean);
    responseHeaders?:
        | Record<string, string>
        | ((headers: Record<string, string>) => boolean);
    statusCode?: number | ((statusCode: number) => boolean);
};

type MoveToOptions = {
    xOffset?: number;
    yOffset?: number;
};

type MultiRemoteBrowserCommandsType = {
    [K in keyof Omit<
        BrowserCommandsType,
        ElementCommandNames | 'SESSION_MOCKS' | 'CDP_SESSIONS'
    >]: (
        ...args: Parameters<BrowserCommandsType[K]>
    ) => Promise<ThenArg<ReturnType<BrowserCommandsType[K]>>[]>;
} & MultiRemoteElementCommands;

type MultiRemoteElementCommandsType = {
    [K in keyof Omit<ElementCommandsType, ElementCommandNames>]: (
        ...args: Parameters<ElementCommandsType[K]>
    ) => Promise<ThenArg<ReturnType<ElementCommandsType[K]>>[]>;
} & MultiRemoteElementCommands;

type MultiRemoteProtocolCommandsType = {
    [K in keyof ProtocolCommands]: (
        ...args: Parameters<ProtocolCommands[K]>
    ) => Promise<ThenArg<ReturnType<ProtocolCommands[K]>>[]>;
};

type NewWindowOptions = {
    type?: 'tab' | 'window';
    windowName?: string;
    windowFeatures?: string;
};

type Origin = 'pointer' | 'viewport';

type PinchAndZoomOptions = {
    duration: number;
    scale: number;
};

type ReactSelectorOptions = {
    props?: Record<string, unknown>;
    state?: Record<string, unknown>;
};

type RestoreMap = Map<SupportedScopes, (() => Promise<any>)[]>;

type Selector =
    | string
    | ElementReference
    | ElementFunction
    | CustomStrategyReference
    | HTMLElement;

type SupportedScopes =
    | 'geolocation'
    | 'userAgent'
    | 'colorScheme'
    | 'onLine'
    | 'clock'
    | 'device';

type SwipeOptions = {
    direction?: `${MobileScrollDirection}`;
    duration?: number;
    from?: XY;
    percent?: number;
    scrollableElement?: WebdriverIO.Element | ChainablePromiseElement;
    to?: XY;
};

type TapOptions = MobileScrollIntoViewOptions & {
    x?: number;
    y?: number;
};

type ThrottleOptions = ThrottlePreset | CustomThrottle;

type ThrottlePreset =
    | 'offline'
    | 'GPRS'
    | 'Regular2G'
    | 'Good2G'
    | 'Regular3G'
    | 'Good3G'
    | 'Regular4G'
    | 'DSL'
    | 'WiFi'
    | 'online';

type TouchActionParameter = string | string[] | TouchAction | TouchAction[];

type TouchActions = TouchActionParameter | TouchActionParameter[];

type WaitForOptions = {
    timeout?: number;
    interval?: number;
    timeoutMsg?: string;
    reverse?: boolean;
    withinViewport?: boolean;
};

type WaitUntilOptions = {
    timeout?: number;
    timeoutMsg?: string;
    interval?: number;
};

type WebdriverIOEventMap = EventMap & {
    dialog: WebdriverIO.Dialog;
};

type XY = {
    x: number;
    y: number;
};