import type { ValueObserverOptions } from './value-observer.js';
import { ValueObserver } from './value-observer.js';
/** Thrown by {@link ObservableValue.getValue} / {@link ObservableValue.setValue} / {@link ObservableValue.subscribe} after the value has been disposed. */
export declare class ObservableAlreadyDisposedError extends Error {
    constructor();
}
export type ValueChangeCallback<T> = (next: T) => void | PromiseLike<void>;
export type ObservableValueOptions<T> = {
    /**
     * Returns `true` to treat `nextValue` as a change (and notify observers),
     * `false` to skip. Defaults to `!==` reference equality.
     */
    compare: (lastValue: T, nextValue: T) => boolean;
    /**
     * Called when an observer callback or filter throws (sync) or rejects
     * (async). Remaining observers are still notified. Defaults to logging
     * via `console.error`.
     */
    onError: (options: {
        error: unknown;
        observer: ValueObserver<T>;
    }) => void;
};
/**
 * Disposable holder for a single value with subscription support.
 *
 * @example
 * ```ts
 * using(new ObservableValue<number>(0), (value) => {
 *   const observer = value.subscribe((next) => console.log('changed:', next))
 *   value.setValue(42)
 *   observer[Symbol.dispose]()
 * })
 * ```
 */
export declare class ObservableValue<T> implements Disposable {
    get isDisposed(): boolean;
    private _isDisposed;
    [Symbol.dispose](): void;
    private observers;
    private currentValue;
    /**
     * Subscribes `callback` to value changes. Dispose the returned
     * {@link ValueObserver} (or call {@link ObservableValue.unsubscribe}) to
     * stop receiving notifications. Throws {@link ObservableAlreadyDisposedError}
     * after disposal.
     */
    subscribe(callback: ValueChangeCallback<T>, options?: ValueObserverOptions<T>): ValueObserver<T>;
    unsubscribe(observer: ValueObserver<T>): boolean;
    /** Throws {@link ObservableAlreadyDisposedError} after disposal. */
    getValue(): T;
    /**
     * Sets the value. Observers are notified only when
     * {@link ObservableValueOptions.compare} reports a change. Throws
     * {@link ObservableAlreadyDisposedError} after disposal.
     */
    setValue(newValue: T): void;
    getObservers(): ReadonlyArray<ValueObserver<T>>;
    private readonly options;
    constructor(initialValue: T, options?: Partial<ObservableValueOptions<T>>);
}
//# sourceMappingURL=observable-value.d.ts.map