import { destructor } from '../destructor';
/** Handler is called when the value of an Observable changes. */
export type Handler<T> = (value: T) => void;
export type AsyncHandler<T> = (value: T) => Promise<void>;
/** A generic interface for an entity whose value can be observed when it changes. */
export interface Observable<T> {
    /**
     * Binds the given handler to the Observable, and starts calling it whenever the
     * value of the Observable changes.
     * @param handler The handler to bind to the Observable.
     * @returns A function that can be called to unbind the handler from the Observable.
     */
    onChange: (handler: Handler<T>) => destructor.Destructor;
}
/** An Observable that can be closed using an async function. */
export interface ObservableAsyncCloseable<T> extends Observable<T> {
    /** Closes the Observable. */
    close: () => Promise<void>;
}
/** A function that transforms a value of type I into a value of type O.
 * @param value The value to transform.
 * @returns A tuple containing the transformed value and a boolean indicating whether
 * the value has changed (i.e. whether the observable should notify its handlers).
 */
export type Transform<I, O> = (value: I) => [O, true] | [O | null, false];
/**
 * An implementation fo the Observable interface that can be manually notified of changes.
 */
export declare class Observer<I, O = I> implements ObservableAsyncCloseable<O> {
    private readonly handlers;
    private readonly transform?;
    private closer?;
    constructor(transform?: Transform<I, O>, handlers?: Map<Handler<O>, null>);
    /** Implements the observable interface. */
    onChange(handler: Handler<O>): destructor.Destructor;
    /** Notifies all handlers that the value of the observable has changed. */
    notify(value: I): void;
    setCloser(closer: () => Promise<void>): void;
    close(): Promise<void>;
}
export declare class BaseObserver<V> implements Observable<V> {
    private readonly handlers;
    constructor(handlers?: Map<Handler<V>, null>);
    onChange(handler: Handler<V>): destructor.Destructor;
    notify(value: V): void;
}
//# sourceMappingURL=observe.d.ts.map