/// <reference types="node" />
import { EventEmitter } from 'events';
import { IPty } from 'node-pty';
import { DriverData, DriverError, DriverOptions } from './interfaces';
declare type Listener<O> = (event: O) => void;
interface Em<Name, Event> extends EventEmitter {
    on(name: Name, listener: Listener<Event>): this;
    once(name: Name, listener: Listener<Event>): this;
    emit(name: Name, options: Event): boolean;
    on(event: string | symbol, listener: (...args: any[]) => void): this;
    once(event: string | symbol, listener: (...args: any[]) => void): this;
    emit(event: string | symbol, ...args: any[]): boolean;
}
interface DriverEmitter extends Em<'start', DriverOptions> {
    eventNames(): EventNames[];
}
declare type EventNames = 'start' | 'data' | 'destroy' | 'exit' | 'error';
/**
 * Core base part of Driver implementation. Takes care of node-pty and emit "data",  "exit" and "start" events
 */
export declare class DriverCore extends EventEmitter implements DriverEmitter {
    eventNames(): EventNames[];
    /**
     * Configuration options of the current instance. Driver is configured on [[start]] but options can be changed
     * later while is running.
     */
    options: DriverOptions;
    protected ptyProcess: IPty;
    protected defaultOptions: DriverOptions;
    /**
     * Starts the client with given options. Will spawn a new terminal
     */
    start(options?: DriverOptions): Promise<this>;
    private _started;
    get started(): boolean;
    private registerDataListeners;
    static systemIsWindows(): boolean;
    private _destroyed;
    get destroyed(): boolean;
    /**
     * destroy current terminal
     */
    destroy(): Promise<this>;
    currentSize: {
        columns: number;
        rows: number;
    };
    getCurrentSize(): {
        columns: number;
        rows: number;
    };
    /**
     * Resizes the dimensions of the pty.
     * @param columns THe number of columns to use.
     * @param rows The number of rows to use.
     */
    resize(columns: number, rows: number): Promise<this>;
    private data;
    protected getData(): Array<DriverData>;
    /**
     * Cleans the data buffer. Useful for making sure that the next data chunk is independent from current state.
     */
    cleanData(): this;
    private handleData;
    static ERROR_TYPE: 'cli-driver-error';
    protected buildError(code: string, description?: any): DriverError;
    /**
     * Return a promise resolved after given number of milliseconds
     * @param ms will resolve the promise only when given number of milliseconds passed
     */
    waitTime(ms: number): Promise<this>;
    time: (ms: number) => Promise<this>;
    sleep: (ms: number) => Promise<this>;
}
export {};