import { EventEmitter } from 'eventemitter3';
export { alto } from './instances/alto.js';
export { anvil } from './instances/anvil.js';
export { tempo } from './instances/tempo.js';
type EventTypes = {
    exit: [code: number | null, signal: NodeJS.Signals | null];
    listening: [];
    message: [message: string];
    stderr: [message: string];
    stdout: [message: string];
};
export type Instance<_internal extends object | undefined = object | undefined> = Pick<EventEmitter<EventTypes>, 'addListener' | 'off' | 'on' | 'once' | 'removeAllListeners' | 'removeListener'> & {
    _internal: _internal;
    /**
     * Creates an instance.
     */
    create(parameters?: {
        port?: number | undefined;
    } | undefined): Omit<Instance<_internal>, 'create'>;
    /**
     * Host the instance is running on.
     */
    host: string;
    /**
     * Name of the instance.
     *
     * @example "anvil"
     */
    name: string;
    /**
     * Port the instance is running on.
     */
    port: number;
    /**
     * Set of messages emitted from the `"message"` event stored in-memory,
     * with length {@link InstanceOptions`messageBuffer`}.
     * Useful for debugging.
     *
     * @example ["Listening on http://127.0.0.1", "Started successfully."]
     */
    messages: {
        clear(): void;
        get(): string[];
    };
    /**
     * Retarts the instance.
     */
    restart(): Promise<void>;
    /**
     * Status of the instance.
     *
     * @default "idle"
     */
    status: 'idle' | 'restarting' | 'stopped' | 'starting' | 'started' | 'stopping';
    /**
     * Starts the instance.
     *
     * @returns A function to stop the instance.
     */
    start(): Promise<() => void>;
    /**
     * Stops the instance.
     */
    stop(): Promise<void>;
};
export type InstanceOptions = {
    /** Number of messages to store in-memory. @default 20 */
    messageBuffer?: number;
    /** Timeout (in milliseconds) for starting and stopping the instance. @default 10_000 */
    timeout?: number;
};
/**
 * Creates an instance definition.
 *
 * @param fn - Function to define the instance.
 *
 * @example
 * ```ts
 * const foo = Instance.define((parameters: FooParameters) => {
 *  return {
 *    name: 'foo',
 *    host: 'localhost',
 *    port: 3000,
 *    async start() {
 *      // ...
 *    },
 *    async stop() {
 *      // ...
 *    },
 *  }
 * })
 * ```
 */
export declare function define<_internal extends object | undefined, parameters = undefined>(fn: define.DefineFn<parameters, _internal>): define.ReturnType<_internal, parameters>;
export declare namespace define {
    type DefineFn<parameters, _internal extends object | undefined = object | undefined> = (parameters: parameters) => Pick<Instance, 'host' | 'name' | 'port'> & {
        _internal?: _internal | undefined;
        start(options: InstanceStartOptions, options_internal: InstanceStartOptions_internal): Promise<void>;
        stop(options_internal: InstanceStopOptions_internal): Promise<void>;
    };
    type ReturnType<_internal extends object | undefined = object | undefined, parameters = undefined> = (...parameters: parameters extends undefined ? [options?: InstanceOptions] : [parameters: parameters, options?: InstanceOptions]) => Instance<_internal>;
    type InstanceStartOptions_internal = {
        emitter: EventEmitter<EventTypes>;
        setEndpoint?(endpoint: {
            host?: string;
            port?: number;
        }): void;
        status: Instance['status'];
    };
    type InstanceStopOptions_internal = {
        emitter: EventEmitter<EventTypes>;
        status: Instance['status'];
    };
    type InstanceStartOptions = {
        /**
         * Port to start the instance on.
         */
        port?: number | undefined;
    };
}
//# sourceMappingURL=Instance.d.ts.map