/// <reference types="node" />
import { EventEmitter } from 'events';
import PluginManager from './PluginSystem/PluginManager';
import { ClientManager, PROCESS_EVENTS, ClientManagerConfig, FetchClientOptions } from './Clients/ClientManager';
import { WORKFLOW_TAGS, PLUGIN_TYPES } from './constants';
import Workflow from './Workflows/Workflow';
import { IPackage, GetKeyOptions } from 'ethpkg';
import IPlugin from './PluginSystem/IPlugin';
import Client, { ClientStartOptions } from './Clients/Client';
import WorkflowManager, { PublishWorkflowOptions, GetWorkflowOptions, CreateWorkflowOptions } from './Workflows/WorkflowManager';
import { StateListener } from './StateListener';
import { Flags } from './Clients/Flags';
export { WORKFLOW_TAGS, PLUGIN_TYPES, PROCESS_EVENTS };
export declare function instanceofClientManagerConfig(object: any): object is ClientManagerConfig;
export interface ILogger {
    listener: StateListener;
}
export interface GridOptions {
    logger?: ILogger;
}
export default class Grid extends EventEmitter {
    pluginManager: PluginManager;
    clientManagers: Array<ClientManager>;
    isReady: boolean;
    workflowManager: WorkflowManager;
    config: {
        [index: string]: any;
    };
    logger: ILogger;
    constructor(options?: GridOptions);
    private init;
    setLogger(logger?: ILogger): void;
    getCachePath(): Promise<any>;
    /**
     * Instead of making this public and having
     * implementers worry about lifecycle or forget to wait about init
     * we should keep this private and just wait in methods were information
     * from init is required
     */
    private whenReady;
    /**
     * returns the list of all evaluated plugin exports
     * i.e. the configuration they produce when run on this machine
     */
    getAllPlugins(): Promise<Array<IPlugin>>;
    createClientManager(config: ClientManagerConfig, pluginCtx?: IPackage): Promise<ClientManager>;
    /**
     * return the list of client managers i.e.
     * wrapped plugins that specify how to fetch and configure eth binaries
     */
    getAllClientManagers(): Promise<Array<ClientManager>>;
    getClientManager(name: string): Promise<ClientManager | undefined>;
    /**
     * returns a list of **all** clients independent of client managers
     * clients refer to binary+config and a state [running, connected]
     */
    getAllClients(): Promise<Array<Client>>;
    getClient(clientManagerSpec: string | ClientManagerConfig, options?: FetchClientOptions): Promise<Client | undefined>;
    startClient(client: Client): Promise<string | undefined>;
    startClient(client: Client, flags: Array<string>, options?: ClientStartOptions): Promise<string | undefined>;
    startClient(client: Client, flags: Flags, options?: ClientStartOptions): Promise<string | undefined>;
    stopClient(client: Client): Promise<unknown>;
    stopClients(...clients: Client[]): Promise<void>;
    /**
     * This will return an unlocked key if it can be found in keystore
     * If not it can create a new one
     * @param options
     */
    getSigningKey(options?: GetKeyOptions): Promise<Buffer>;
    createWorkflow(options: CreateWorkflowOptions): Promise<string>;
    loadWorkflow(workflowPathOrPkg: string | IPackage): Promise<Workflow>;
    getAllWorkflows(): Promise<Array<Workflow>>;
    getWorkflow(workflowSpec: string, options?: GetWorkflowOptions): Promise<Workflow | undefined>;
    publishWorkflow(workflowPath: string, options?: PublishWorkflowOptions): Promise<import("ethpkg").IRelease>;
    startWebApp(queryOrUrl: string, { listener }?: any): Promise<void>;
    startApiServer(): Promise<void>;
}
//# sourceMappingURL=Grid.d.ts.map