export interface ObserverCallback<EventName extends keyof any> {
    (event: EventName, ...args: Array<any>): void;
}
export interface ObserverDestructor {
    (): void;
}
export declare type ObserverCallbackArray<EventName extends keyof any> = Array<ObserverCallback<EventName>>;
export declare type ObserverRecord<EventName extends keyof any> = Record<EventName, ObserverCallbackArray<EventName>>;
/**
 * This is a simple observer implementation for implementing synchronous in-process events for a local service.
 *
 * You'll use it like:
 *
 * ```
 * enum FooEvent {
 *     CHANGED = "FooService:changed"
 * }
 *
 * class FooService {
 *
 *     private static _data : any;
 *     private static _observer : Observer<FooEvent> = {};
 *
 *     public static getData () : any {
 *         return this._data;
 *     }
 *
 *     public static on (name : FooEvent, callback) : ObserverDestructor {
 *         return this._observer.listenEvent(name, callback);
 *     }
 *
 *     public static refreshData () {
 *
 *         HttpService.doSomething().then((response) => {
 *
 *             this._data = response.data;
 *
 *             this._observer.triggerEvent(FooEvent.CHANGED);
 *
 *         }).catch(err => {
 *             console.error('Error: ', err);
 *         });
 *
 *     }
 *
 * }
 *
 * FooService.on(FooEvent.CHANGED, () => {
 *
 *     const currentData = FooService.getData();
 *     // ...
 *
 * });
 *
 * FooService.refreshData();
 *
 * ```
 *
 */
export declare class Observer<EventName extends keyof any> {
    private _name;
    private _callbacks;
    getName(): string;
    /**
     *
     * @param name You can name this observer, so that you know where it is used.
     */
    constructor(name: string);
    /**
     * Destroy the observer data. Stop using this object after you use destroy.
     */
    destroy(): void;
    /**
     * Check if eventName has listeners.
     *
     * @param eventName
     */
    hasCallbacks(eventName: EventName): boolean;
    /**
     * Trigger an event
     *
     * @param eventName
     * @param args
     */
    triggerEvent(eventName: EventName, ...args: Array<any>): void;
    /**
     * Start listening events.
     *
     * Returns destructor function.
     *
     * @param eventName
     * @param callback
     */
    listenEvent(eventName: EventName, callback: ObserverCallback<EventName>): ObserverDestructor;
    /**
     * Removes the first found listener callback for eventName
     *
     * @param eventName
     * @param callback
     */
    removeListener(eventName: EventName, callback: ObserverCallback<EventName>): void;
}
export default Observer;