/// <reference types="node" />
/// <reference types="node" />
import { AdbClientOptions, InputDurationOptions, CommandConstruct, CpOptions, ForwardsObject, IDevice, InputSource, InstallOptions, KeyEventOptions, LogcatOptions, MkDirOptions, MvOptions, ReversesObject, RmOptions, SettingsMode, PrimitiveType, StartActivityOptions, StartServiceOptions, TouchOptions, UninstallOptions, WaitForState, PropertyMap, NonEmptyArray, WaitForType, PropertyValue, TransportCommandConstruct, KeyCode } from './util';
import { SyncMode } from './sync';
import { Device } from './device';
import { Connection } from './connection';
import { FileStat } from './filestats';
import { LogcatReader } from './logcat/reader';
import { Monkey } from './monkey/client';
import { PullTransfer } from './sync/pulltransfer';
import { PushTransfer } from './sync/pushtransfer';
import { Readable } from 'stream';
import SyncEntry from './sync/entry';
import { Tracker } from './tracker';
export declare class Client {
    private options;
    /**
     * @param {AdbClientOptions} options see AdbClientOptions for more details
     */
    constructor(options?: AdbClientOptions);
    /**
     * Starts adb server if not running.
     */
    startServer(): Promise<void>;
    private connection;
    transport(serial: string): Promise<Connection>;
    /**
     * Gets the adb server version.
     */
    version(): Promise<number>;
    private ipConnect;
    /**
     * Connects to device over local network.
     * @example
     * adb.map(async (device) => {
     *    await device.tcpip();
     *    const [ip] = await device.getIpAddress();
     *    await adb.connect(ip);
     *});
     */
    connect(host: string): Promise<string>;
    connect(host: string, port: number): Promise<string>;
    /**
     * Disconnects from the given device.
     */
    disconnect(host: string): Promise<string>;
    disconnect(host: string, port: number): Promise<string>;
    /**
     * Gets the list of currently connected devices and emulators.
     */
    listDevices(): Promise<IDevice[]>;
    /**
     * Tracks connection status of devices.
     */
    trackDevices(): Promise<Tracker>;
    /**
     * Kills the adb server.
     */
    kill(): Promise<void>;
    /**
     * Gets the serial number of the device.
     * Meant for getting serial number of local devices.
     * Analogous to `adb shell getprop ro.serialno`.
     */
    getSerialNo(serial: string): Promise<string>;
    /**
     * Gets the device path of the device identified by the device.
     */
    getDevicePath(serial: string): Promise<string>;
    /**
     * Lists properties of the device.
     * Analogous to `adb shell getprop`.
     */
    listProperties(serial: string): Promise<PropertyMap>;
    /**
     * Lists features of the device.
     * Analogous to `adb shell pm list features`.
     */
    listFeatures(serial: string): Promise<PropertyMap>;
    /**
     * Lists installed packages.
     * Analogous to `adb shell pm list packages`.
     */
    listPackages(serial: string): Promise<string[]>;
    /**
     * Gets the ipv4 addresses of default wlan interface.
     */
    getIpAddress(serial: string): Promise<string[]>;
    /**
     * Forwards socket connections from the ADB server host (local) to the device (remote).
     * Analogous to `adb forward <local> <remote>`.
     * @example
     * adb.forward('serial', 'tcp:9222', 'localabstract:chrome_devtools_remote')
     */
    forward(serial: string, local: string, remote: string): Promise<void>;
    /**
     * Lists all forwarded connections.
     * Analogous to `adb forward --list`.
     */
    listForwards(serial: string): Promise<ForwardsObject[]>;
    /**
     * Reverses socket connections from the device (remote) to the ADB server host (local).
     * Analogous to `adb reverse <remote> <local>`.
     * @example
     * adb.reverse('serial', 'localabstract:chrome_devtools_remote', 'tcp:9222')
     */
    reverse(serial: string, local: string, remote: string): Promise<void>;
    /**
     * Lists all reversed connections.
     * Analogous to `adb reverse --list`.
     */
    listReverses(serial: string): Promise<ReversesObject[]>;
    private deleteApk;
    /**
     * Reboots the device.
     * Analogous to `adb reboot`.
     */
    reboot(serial: string): Promise<void>;
    /**
     * Shuts the device down.
     * Analogous to `adb reboot -p`.
     */
    shutdown(serial: string): Promise<void>;
    /**
     * Attempts to remount the `/system` partition in read-write mode.
     * Can be done on a rooted device. Analogous to `adb remount`.
     * Analogous to `adb remount`
     */
    remount(serial: string): Promise<void>;
    /**
     * Attempts to which the device to the root mode.
     * Analogous to `adb root`.
     */
    root(serial: string): Promise<void>;
    /**
     * Takes a screenshot on the specified device.
     * Analogous to `adb shell screencap -p`.
     */
    screenshot(serial: string): Promise<Buffer>;
    /**
     * Opens a direct TCP connection to specified port on the device.
     * Analogous to `adb tcp <port>:<host>`.
     * @example
     * const socket = await adb.openTcp('serial', 5555);
     * // socket.write(...)
     */
    openTcp(serial: string, port: number): Promise<Connection>;
    openTcp(serial: string, port: number, host: string): Promise<Connection>;
    /**
     * Sends roll input command to the device shell.
     * Analogous to `adb shell input trackball roll <x> <y>`.
     * Default input source is `trackball`.
     * @param x Horizontal coordinate.
     * @param y Vertical coordinate.
     */
    roll(serial: string, x: number, y: number): Promise<void>;
    roll(serial: string, x: number, y: number, source: InputSource): Promise<void>;
    /**
     * Sends roll input command to the device shell.
     * Analogous to `adb shell input trackball press`.
     * Default input source is `trackball`.
     */
    press(serial: string): Promise<void>;
    press(serial: string, source: InputSource): Promise<void>;
    /**
     * Sends draganddrop input command to the device shell.
     * Analogous to `adb shell input touchscreen draganddrop x1 y1 x2 y2`.
     * Default input source is `touchscreen`.
     * @param x1 Horizontal starting coordinate.
     * @param y1 Vertical starting coordinate.
     * @param x2 Horizontal ending coordinate.
     * @param y2 Vertical ending coordinate.
     */
    dragAndDrop(serial: string, x1: number, y1: number, x2: number, y2: number): Promise<void>;
    dragAndDrop(serial: string, x1: number, y1: number, x2: number, y2: number, options: InputDurationOptions): Promise<void>;
    /**
     * Sends swipe input command to the device shell.
     * Analogous to `adb shell input touchscreen swipe x1 y1 x2 y2`.
     * Default input source is `touchscreen`.
     * @param x1 Horizontal starting coordinate.
     * @param y1 Vertical starting coordinate.
     * @param x2 Horizontal ending coordinate.
     * @param y2 Vertical ending coordinate.
     */
    swipe(serial: string, x1: number, y1: number, x2: number, y2: number): Promise<void>;
    swipe(serial: string, x1: number, y1: number, x2: number, y2: number, options: InputDurationOptions): Promise<void>;
    /**
     * Sends keyevent input command to the device shell.
     * Analogous to `adb shell input keyboard keyevent <code>`.
     * Default input source is `keyboard`.
     * @param code Key code to send.
     */
    keyEvent(serial: string, code: KeyCode | NonEmptyArray<KeyCode>): Promise<void>;
    keyEvent(serial: string, code: number | NonEmptyArray<number>): Promise<void>;
    keyEvent(serial: string, code: KeyCode | NonEmptyArray<KeyCode>, options: KeyEventOptions): Promise<void>;
    /**
     * Sends tap input command to the device shell.
     * Analogous to `adb shell input touchscreen tap <x> <y>`.
     * Default input source is `touchscreen`.
     * @param x Horizontal coordinate.
     * @param y Vertical coordinate.
     */
    tap(serial: string, x: number, y: number): Promise<void>;
    tap(serial: string, x: number, y: number, source: InputSource): Promise<void>;
    /**
     * Sends text input command to the device shell.
     * Analogous to `adb shell input touchscreen text '<text>'`.
     * Default input source is `touchscreen`.
     */
    text(serial: string, text: string): Promise<void>;
    text(serial: string, text: string, source: InputSource): Promise<void>;
    /**
     * Opens logcat.
     * Analogous to `adb logcat`.
     * @see `LogcatReader` and `LogcatOptions` for more details.
     * @example
     * import { Client, Priority } from 'adb-ts';
     * const adb = new Client();
     * const logcat = await adb.openLogcat('serial', {
     *     filter: (entry) => entry.priority > Priority.INFO
     * });
     * logcat.on('entry', (entry) => {
     *     console.log(entry);
     * });
     */
    openLogcat(serial: string): Promise<LogcatReader>;
    openLogcat(serial: string, options: LogcatOptions): Promise<LogcatReader>;
    private syncService;
    /**
     * Deletes all data associated with a package from the device.
     * Analogous to `adb shell pm clear <pkg>`.
     */
    clear(serial: string, pkg: string): Promise<void>;
    private installRemote;
    /**
     * Installs an apk to the device.
     * Analogous to `adb install <pkg>`.
     */
    install(serial: string, apk: string | Readable): Promise<void>;
    install(serial: string, apk: string | Readable, options: InstallOptions): Promise<void>;
    /**
     * @param args Extra arguments. E.g. `--fastdeploy` flag.
     */
    install(serial: string, apk: string | Readable, options: InstallOptions, args: string): Promise<void>;
    /**
     * Uninstalls a package from the device.
     * Analogous to `adb uninstall`.
     */
    uninstall(serial: string, pkg: string): Promise<void>;
    uninstall(serial: string, pkg: string, options: UninstallOptions): Promise<void>;
    /**
     * Tells if a package is installed or not.
     */
    isInstalled(serial: string, pkg: string): Promise<boolean>;
    /**
     * Starts a new activity with options.
     * Analogous to `adb shell am start <pkg./activity>`.
     */
    startActivity(serial: string, pkg: string, activity: string): Promise<void>;
    startActivity(serial: string, pkg: string, activity: string, options: StartActivityOptions): Promise<void>;
    /**
     * Starts a new service with options.
     * Analogous to `adb shell am startservice <pkg> <service>`.
     */
    startService(serial: string, pkg: string, service: string): Promise<void>;
    startService(serial: string, pkg: string, service: string, options: StartServiceOptions): Promise<void>;
    /**
     * Reads given directory.
     * The path should start with `/`.
     */
    readDir(serial: string, path: string): Promise<SyncEntry[]>;
    /**
     * Gets a PullTransfer instance.
     * @see `PullTransfer`
     * @example
     * let data = '';
     * const transfer = await adb.pull('serial', '/path')
     * transfer.on('data', (chunk) => {
     *     data += chunk.toString();
     * });
     * transfer.on('end', () => {
     *     console.log(data);
     * });
     */
    pull(serial: string, path: string): Promise<PullTransfer>;
    /**
     * Gets a PushTransfer instance.
     * @see `PushTransfer`
     * @example
     * const transfer = await adb.push('serial', '/path-src', '/path-dest')
     * transfer.on('end', () => { });
     */
    push(serial: string, srcPath: string | Readable, destPath: string): Promise<PushTransfer>;
    push(serial: string, srcPath: string | Readable, destPath: string, mode: SyncMode): Promise<PushTransfer>;
    private awaitActiveDevice;
    /**
     * Puts the device ADB daemon into tcp mode.
     * Afterwards it is possible to use `connect` method.
     * Analogous to `adb tcpip 5555`.
     */
    tcpip(serial: string): Promise<void>;
    tcpip(serial: string, port: number): Promise<void>;
    /**
     * Sets the device transport back to usb.
     */
    usb(serial: string): Promise<void>;
    /**
     * Waits until the device has finished booting.
     */
    waitBootComplete(serial: string): Promise<void>;
    /**
     * Waits until the device is in the given state.
     * Analogous to `adb wait-for-<transport>-<state>`.
     */
    waitFor(transport: WaitForType, state: WaitForState): Promise<void>;
    /**
     * Maps through all connected devices.
     */
    map<T>(mapper: (device: Device) => Promise<T> | T): Promise<T[]>;
    private pushInternal;
    /**
     * Wraps {@link push} method, provides API for quick data writing.
     */
    pushDataToFile(serial: string, data: string | Buffer | Readable, destPath: string): Promise<void>;
    /**
     * Wraps {@link push} method, reads the content of file on the host to a file on the device.
     */
    pushFile(serial: string, srcPath: string, destPath: string): Promise<void>;
    /**
     * Wraps {@link pull} method, reads the file content and resolves with the output.
     */
    pullDataFromFile(serial: string, srcPath: string): Promise<Buffer>;
    /**
     * Wraps {@link pull} method, reads the content of file on the device and write it to a file on the machine.
     */
    pullFile(serial: string, srcPath: string, destPath: string): Promise<void>;
    /**
     * Sets property on the device.
     * Analogues to `adb shell setprop <prop> <value>`.
     */
    setProp(serial: string, prop: string, value: PrimitiveType): Promise<void>;
    /**
     * Gets property from the device.
     * Analogues to `adb shell getprop <prop>`.
     */
    getProp(serial: string, prop: string): Promise<PropertyValue>;
    /**
     * Puts setting on the device.
     * Analogues to `adb shell settings put <mode> <name> <value>`.
     */
    putSetting(serial: string, mode: SettingsMode, name: string, value: PrimitiveType): Promise<void>;
    /**
     * Lists settings of the device.
     * Analogues to `adb shell settings list <mode>`.
     */
    listSettings(serial: string, mode: SettingsMode): Promise<PropertyMap>;
    /**
     * Gets setting from the device.
     * Analogues to `adb shell settings get <mode> <name>`.
     */
    getSetting(serial: string, mode: SettingsMode, name: string): Promise<PropertyValue>;
    /**
     * Executes a given shell command via adb console interface. Analogous to `adb -s <serial> shell <command>`.
     */
    shell(serial: string, command: string): Promise<string>;
    /**
     * Enables to execute any custom command.
     * @example
     *   class MyCommand extends Command<number> {
     *   protected autoEnd = true;
     *   private arg: string;
     *   constructor(connection: Connection, arg: string) {
     *       super(connection);
     *       this.arg = arg;
     *   }
     *   async execute(): Promise<number> {
     *       const reply = await this.initExecute(this.arg);
     *       switch (reply) {
     *           case Reply.OKAY:
     *               const value = await this.parser.readValue();
     *               return parseInt(value.toString(), 10);
     *           case Reply.FAIL:
     *               throw await this.parser.readError();
     *           default:
     *               return parseInt(reply, 10);
     *          }
     *      }
     *  }
     */
    custom<T, P extends unknown[] = unknown[]>(CustomCommand: CommandConstruct<T, P>, ...args: P): Promise<T>;
    /**
     * Enables to execute any custom transport command.
     * @example
     *    class MyCommand extends TransportCommand<null> {
     *    protected keepAlive = false;
     *    private arg: string;
     *    constructor(connection: Connection, serial: string, arg: string) {
     *        super(connection, serial);
     *        this.arg = arg;
     *    }
     *    protected get Cmd() {
     *        return 'test '.concat(this.arg);
     *    }
     *    protected postExecute(): null {
     *        return null;
     *    }
     * }
     */
    customTransport<T, P extends unknown[] = unknown[]>(CustomCommand: TransportCommandConstruct<T, P>, serial: string, ...args: P): Promise<T>;
    /**
     * Establishes a new monkey connection on port `1080`.
     */
    openMonkey(serial: string): Promise<Monkey>;
    /**
     * Force stops given package.
     * Analogous to `adb shell am force-stop <package>`.
     */
    killApp(serial: string, pkg: string): Promise<void>;
    private execInternal;
    /**
     * Executes a given command via adb console interface.
     * If cmd contains arguments, they need to be passed as and string[], not string. @see https://github.com/Maaaartin/adb-ts/issues/13
     */
    exec(cmd: string | string[]): Promise<string>;
    /**
     * Executes a given command on specific device via adb console interface.
     * Analogous to `adb -s <serial> <command>`.
     * If cmd contains arguments, they need to be passed as and string[], not string. @see https://github.com/Maaaartin/adb-ts/issues/13
     */
    execDevice(serial: string, cmd: string | string[]): Promise<string>;
    /**
     * Executes a given command on specific device shell via adb console interface.
     * Analogous to `adb -s <serial> shell <command>` .
     */
    execDeviceShell(serial: string, cmd: string | string[]): Promise<string>;
    /**
     * Retrieves current battery status.
     * Analogous to `adb -s <serial> shell dumpsys battery` .
     */
    batteryStatus(serial: string): Promise<PropertyMap>;
    /**
     * Removes file/folder specified by `path` parameter.
     * Analogous to `adb shell rm <path>`.
     */
    rm(serial: string, path: string): Promise<void>;
    rm(serial: string, path: string, options: RmOptions): Promise<void>;
    /**
     * Creates directory specified by `path` parameter.
     * Analogous to `adb shell mkdir <path>`.
     */
    mkdir(serial: string, path: string): Promise<void>;
    mkdir(serial: string, path: string, options: MkDirOptions): Promise<void>;
    /**
     * Updates access and modification times of file specified by `path` parameter, or creates a new file.
     * Analogous to `adb shell touch <filename>`.
     */
    touch(serial: string, path: string): Promise<void>;
    touch(serial: string, path: string, options: TouchOptions): Promise<void>;
    /**
     * Moves data with `srcPath` to `destPath` parameter.
     * Analogous to `adb shell mv <src> <dest>`.
     */
    mv(serial: string, srcPath: string, destPath: string): Promise<void>;
    mv(serial: string, srcPath: string, destPath: string, options: MvOptions): Promise<void>;
    /**
     * Copies data with `srcPath` to `destPath` parameter.
     * Analogous to `adb shell cp <src> <dest>`.
     */
    cp(serial: string, srcPath: string, destPath: string): Promise<void>;
    cp(serial: string, srcPath: string, destPath: string, options: CpOptions): Promise<void>;
    /**
     * Gets file stats for specified path.
     * Analogous to `adb stat <filepath>`.
     */
    fileStat(serial: string, path: string): Promise<FileStat>;
}