webdriverio

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.MultiRemoteCapabilities,
    { automationProtocol }?: { automationProtocol?: string }
) => Promise<WebdriverIO.MultiRemoteBrowser>;

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

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

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

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

type ClickOptions = {
    button?: number | string;
    x?: number;
    y?: number;
    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 ErrorCode =
    | 'Failed'
    | 'Aborted'
    | 'TimedOut'
    | 'AccessDenied'
    | 'ConnectionClosed'
    | 'ConnectionReset'
    | 'ConnectionRefused'
    | 'ConnectionAborted'
    | 'ConnectionFailed'
    | 'NameNotResolved'
    | 'InternetDisconnected'
    | 'AddressUnreachable'
    | 'BlockedByClient'
    | 'BlockedByResponse';

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

type MixedContentType = 'blockable' | 'optionally-blockable' | 'none';

type MockFilterOptions = {
    method?: string | ((method: string) => boolean);
    headers?:
        | Record<string, string>
        | ((headers: Record<string, 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);
    postData?: string | ((payload: string | undefined) => boolean);
};

type MockOverwrite = string | Record<string, any> | MockOverwriteFunction;

type MockOverwriteFunction = (
    request: Matches,
    client: CDPSession
) => Promise<string | Record<string, any>>;

type MockResponseParams = {
    statusCode?: number | ((request: Matches) => number);
    headers?:
        | Record<string, string>
        | ((request: Matches) => Record<string, string>);
    /**
     * fetch real response before responding with mocked data. Default: true
     */
    fetchResponse?: 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 = {
    windowName?: string;
    windowFeatures?: string;
};

type ReactSelectorOptions = {
    props?: object;
    state?: any[] | number | string | object | boolean;
};

type ReferrerPolicy =
    | 'unsafe-url'
    | 'no-referrer-when-downgrade'
    | 'no-referrer'
    | 'origin'
    | 'origin-when-cross-origin'
    | 'same-origin'
    | 'strict-origin'
    | 'strict-origin-when-cross-origin';

type RemoteOptions = Options.WebdriverIO &
    Omit<Options.Testrunner, 'capabilities' | 'rootDir'>;

type ResourcePriority = 'VeryLow' | 'Low' | 'Medium' | 'High' | 'VeryHigh';

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

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;
};

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