/// <reference types="node" />
import { ICommand, IDataEmitter, IDataEvent, IDataEventListener, IDataEventListenerFunc, IDisposable, IEmitterDescription, IExecutionResult, IFormatSettings, ISettings, IStatusChangeListener, IStatusChangeListenerFunc, IStatusEvent, ITraceableAction } from './dataEmitter';
import { LoggerFacade, LogLevel } from './loggerFacade';
import EventEmitter from 'events';
/**
 *
 */
export declare class BaseStatusEvent implements IStatusEvent {
    emitter: IDataEmitter;
    connected: boolean;
    bit: boolean;
    timestamp: Date;
    /**
       *
       * @param {boolean} connected
       * @param {boolean} bit
       * @param {IDataEmitter} emitter
       * @param {Date} timestamp
       */
    constructor(connected: boolean, bit: boolean, emitter: IDataEmitter, timestamp?: Date);
    /**
       * @return {Record<string, unknown>}
       */
    toJSON(): Record<string, unknown>;
}
/**
 * Create a base data event
 */
export declare class BaseDataEvent implements IDataEvent {
    readonly emitter: IDataEmitter;
    readonly timestamp: Date;
    readonly data: unknown;
    readonly meta: unknown;
    /**
       * Create a data event object
       * @param {IDataEmitter} emitter
       * @param {unknown} data
       * @param {unknown} meta
       */
    constructor(emitter: IDataEmitter, data: unknown, meta: unknown);
    /**
       * Converts the object into a JSON friendly object
       * @return {Record<string, unknown>}
       */
    toJSON(): Record<string, unknown>;
}
/**
 * Abstract base class emitter that takes care of managing registrations of
 * listeners and cleanup on disposal
 */
export declare abstract class BaseEmitter extends EventEmitter implements IDataEmitter, IDisposable {
    private _id;
    private _name;
    private _description;
    protected _logger: LoggerFacade | undefined;
    /**
       * Listener collection for data change listeners
       */
    private readonly _dataListeners;
    /**
       * Listener collection for status change listeners
       */
    private readonly _statusListeners;
    /**
       * connected state
       */
    private _connected;
    /**
       * faulted state
       */
    private _faulted;
    /**
       * DC check interval handle
       * @private
       */
    private _dcInterval?;
    /**
       * amount of time between dc checks
       * @private
       */
    private _dcIntervalms?;
    /**
       * amount of time since successful message emission till we consider
       * the state to be disconnected
       * @private
       */
    private _dcThresholdMs;
    /**
       * The last time the source has successfully produced data
       * @private
       */
    private _dcLastHeardTime?;
    /**
       * @return {string} unique id for emitter
       */
    get id(): string;
    /**
       * @return {string} emitter name
       */
    get name(): string;
    /**
       * @return {string} communication link description
       */
    get description(): string;
    /**
       *
       * @param {string} _id
       * @param {string} _name
       * @param {string} _description
       * @param {LoggerFacade|undefined} _logger
       */
    constructor(_id: string, _name: string, _description: string, _logger?: LoggerFacade | undefined);
    /**
       * serialize the important data that is needed to be able to recreate this emitter in it's current state
       * @param {IFormatSettings} settings used to specify expected format of the serialization
       * @return {Promise<string>}
       */
    serializeState(settings: IFormatSettings): Promise<string>;
    /**
       * Control serialized properties when JSON.stringify is called
       * @return {Record<string, unknown>}
       */
    toJSON(): Record<string, unknown>;
    /**
       *
       * @param {IDataEvent} evt
       */
    protected notifyDataListeners(evt: IDataEvent): void;
    /**
       *
       * @param {IDataEventListener} listener
       * @return {IDisposable}
       */
    onData(listener: IDataEventListener | IDataEventListenerFunc): IDisposable;
    /**
       *
       * @param {IStatusEvent} evt
       */
    protected notifyStatusListeners(evt: IStatusEvent): void;
    /**
       *
       * @param {string} name
       */
    protected setName(name: string): void;
    /**
       *
       * @param {string} description
       */
    protected setDescription(description: string): void;
    /**
       * Set the unique identifier for the emitter
       * @param {string} id
       */
    protected setId(id: string): void;
    /**
       * Takes a simple function listener parameter and turns it into the listener interface
       * format
       * @param {IStatusChangeListenerFunc} listener
       * @return {IStatusChangeListener}
       */
    protected wrapStatusListener(listener: IStatusChangeListenerFunc): IStatusChangeListener;
    /**
       * Wrap a data listener function into a {IDataEventListener}
       * @param {IDataEventListenerFunc} listener
       * @return {IDataEventListener}
       */
    protected wrapDataListener(listener: IDataEventListenerFunc): IDataEventListener;
    /**
       *
       * @param {IStatusChangeListener} listener
       * @return {IDisposable}
       */
    onStatus(listener: IStatusChangeListener | IStatusChangeListenerFunc): IDisposable;
    /**
       * Clear any faults and notify listeners of change if change
       */
    protected clearIfFaulted(): void;
    /**
       * faulted
       */
    protected faulted(): void;
    /**
       * connected
       */
    protected connected(): void;
    /**
       * disconnected
       */
    protected disconnected(): void;
    /**
       * build a status event
       * @return {IStatusEvent}
       */
    protected buildStatusEvent(): IStatusEvent;
    /**
       * build a data event
       * @param {unknown} data
       * @return {IDataEvent}
       */
    protected buildDataEvent(data: unknown): IDataEvent;
    /**
       * Sets how frequently the dc check is executed
       * @param {number} checkInterval
       * @param {number} threshold
       * @protected
       */
    protected setDCCheckInterval(checkInterval: number, threshold: number): void;
    /**
       * Execute logic to detect disconnections and notify listeners
       * @private
       */
    private dcHandler;
    /**
       * Apply settings to the emitter, this could be emitter settings
       * such as poll intervel, d/c threshold, or use the additional
       * property to apply settings to the underlying source
       * @param {ISettings} settings
       * @return {Promise<IExecutionResul>}
       */
    applySettings(settings: ISettings & ITraceableAction): Promise<IExecutionResult>;
    /**
       * Prefix a log message with information about the emitter
       * @param {string} msg
       * @return {string}
       */
    protected prefixLogMessage(msg: string): string;
    /**
       * Log information
       * @param {LogLevel} level
       * @param {String} msg
       * @return {void}
       */
    protected log(level: LogLevel, msg: string): void;
    /**
     * Send a command to the emitter, this could change emitter behavior,
     * write something directly the unlderying source etc.
     * @param {ITraceableAction} command
     * @return {Promise<IExecutionResult>}
     */
    abstract sendCommand(command: ICommand): Promise<IExecutionResult>;
    /**
     * Fetch the latest state information such as connectivity
     * from the emitter, this could be cached from last event emission or generated
     * each time
     * @return {Promise<ITraceableAction>}
     */
    abstract probeStatus(): Promise<IStatusEvent>;
    /**
     * Probe the current data, this could return the
     * last emitted data for event based streams,
     * or actually trigger fetching the latest from the
     * source
     * @return {Promise<IDataEvent>}
     */
    abstract probeCurrentData(): Promise<IDataEvent>;
    /**
     * Get meta data associated with this emitter, this varies
     * per emitter implementation
     * @return {unknown}
     */
    abstract getMetaData(): unknown;
    /**
     * Get the emitter type for this emitter
     */
    abstract getType(): string;
    /**
     * Gets the emitter description which is used to recreate the emitter
     * @return {IEmitterDescription}
     */
    protected getEmitterDescription(): IEmitterDescription;
    /**
     *
     * @return {unknown}
     */
    protected getEmitterProperties(): unknown;
    /**
     *
     * @param {string} stateData
     * @param {IFormatSettings} settings
     */
    static recreateEmitter(stateData: string, settings: IFormatSettings): Promise<IDataEmitter>;
    /**
     * Cleanup any resources/timers managed by the
     * emitter
     */
    dispose(): void;
}