@applitools/driver/types/driver.d.ts

Applitools universal framework wrapper

/// <reference types="node" />
import type { Size, Region } from '@applitools/utils';
import type { DriverInfo, Capabilities, UserAgent, Environment, Viewport, Features, ScreenOrientation, Cookie } from './types';
import { type Selector } from './selector';
import { type SpecType, type SpecDriver, type WaitOptions } from './spec-driver';
import { type Element } from './element';
import { type Logger } from '@applitools/logger';
import { Context, type ContextReference } from './context';
import { HelperIOS } from './helper-ios';
import { HelperAndroid } from './helper-android';
import { inspect } from 'util';
type DriverState<T extends SpecType> = {
    nmlElement?: Element<T> | null;
};
type DriverOptions<T extends SpecType> = {
    spec: SpecDriver<T>;
    driver: T['driver'];
    logger?: Logger;
    customConfig?: {
        useCeilForViewportSize?: boolean;
    };
};
export declare class Driver<T extends SpecType> {
    private _target;
    private _mainContext;
    private _currentContext;
    private _driverInfo?;
    private _environment?;
    private _viewport?;
    private _features?;
    private _helper?;
    private _state;
    private _customConfig;
    private _logger;
    protected readonly _spec: SpecDriver<T>;
    protected readonly _original: this;
    constructor(options: DriverOptions<T>);
    [inspect.custom](): {
        driverInfo: DriverInfo | undefined;
        environment: Environment | undefined;
        viewport: Viewport | undefined;
        helper: HelperAndroid<T> | HelperIOS<T> | null | undefined;
        state: DriverState<T>;
        customConfig: {
            useCeilForViewportSize?: boolean | undefined;
        };
        features: Features | undefined;
    };
    get logger(): Logger;
    get target(): T['driver'];
    get guid(): string;
    get currentContext(): Context<T>;
    get mainContext(): Context<T>;
    updateLogger(logger: Logger): void;
    updateCurrentContext(context: Context<T>): void;
    reloadPage(): Promise<this>;
    refresh({ reset, name }?: {
        reset?: boolean;
        name?: string;
    }): Promise<this>;
    getDriverInfo({ force }?: {
        force?: boolean;
    }): Promise<DriverInfo>;
    getCapabilities({ force }?: {
        force?: boolean;
    }): Promise<Capabilities | null>;
    getUserAgent({ force }?: {
        force?: boolean;
    }): Promise<UserAgent | undefined>;
    getUserAgentLegacy({ force }?: {
        force?: boolean;
    }): Promise<string | undefined>;
    getEnvironment(): Promise<Environment>;
    getViewport({ keepNavigationBar }?: {
        keepNavigationBar?: boolean;
    }): Promise<Viewport>;
    getFeatures(): Promise<Features>;
    getSessionId(): Promise<string | null>;
    getDriverUrl(): Promise<string | null>;
    getHelper(): Promise<HelperAndroid<T> | HelperIOS<T> | null>;
    extractBrokerUrl(): Promise<string | null>;
    getSessionMetadata(): Promise<any | undefined>;
    getWorlds(): Promise<string[] | null>;
    getCurrentWorld(): Promise<string | null>;
    switchWorld(name?: string): Promise<void>;
    switchTo(context: Context<T>): Promise<Context<T>>;
    switchToMainContext(): Promise<Context<T>>;
    switchToParentContext(elevation?: number): Promise<Context<T>>;
    switchToChildContext(...references: ContextReference<T>[]): Promise<Context<T>>;
    normalizeRegion(region: Region): Promise<Region>;
    getRegionInViewport(context: Context<T>, region: Region): Promise<Region>;
    takeScreenshot(): Promise<Uint8Array>;
    getViewportSize(): Promise<Size>;
    setViewportSize(size: Size): Promise<void>;
    getDisplaySize(): Promise<Size | undefined>;
    getOrientation(): Promise<ScreenOrientation | undefined>;
    setOrientation(orientation: 'portrait' | 'landscape'): Promise<void>;
    getCookies(): Promise<Cookie[]>;
    getTitle(): Promise<string>;
    getUrl(): Promise<string>;
    element(selector: Selector<T>): Promise<Element<T> | null>;
    elements(selector: Selector<T>): Promise<Element<T>[]>;
    waitFor(selector: Selector<T>, options?: WaitOptions): Promise<Element<T> | null>;
    execute(script: ((arg: any) => any) | string, arg?: any): Promise<any>;
    executeUserFunction<T>(func: SpecType['userFunction'] | (() => T)): Promise<any>;
    visit(url: string): Promise<void>;
}
export declare function isDriverInstance<T extends SpecType>(driver: any): driver is Driver<T>;
export declare function isDriver<T extends SpecType>(driver: any, spec?: SpecDriver<T>): driver is Driver<T> | T['driver'] | T['secondary']['driver'];
export declare function makeDriver<T extends SpecType>(options: {
    driver: Driver<T> | T['driver'] | T['secondary']['driver'];
    spec?: SpecDriver<T>;
    customConfig?: {
        useCeilForViewportSize?: boolean;
    };
    reset?: boolean;
    logger?: Logger;
}): Promise<Driver<T>>;
export {};