import { NextObserver, Observable, Subject, Subscribable, Subscription, Unsubscribable } from "rxjs";
import { CheckPhase, DeferredValueOptions, ValueOptions } from "./interfaces";
import { EventEmitter } from "@angular/core";
export declare const trackedValues: Map<any, Set<any>>;
export declare const pendingObservers: Set<any>;
export declare function setPending(value: boolean): boolean;
export declare function flush(): void;
export declare class Value<T> implements NextObserver<T> {
    readonly __ng_value: boolean;
    readonly __check_phase: number;
    check?: (oldValue: T, newValue: T) => boolean;
    source: Subject<T>;
    errors: Set<(error: unknown) => Observable<any> | void>;
    changes: Set<(previous: T, current: T) => void>;
    get value(): T;
    set value(nextValue: T);
    isDirty(value: T): boolean;
    call(this: any, context: any, ...args: any[]): any;
    apply(this: any, context: any, args: any[]): any;
    bind(): this;
    subscribe(observer: any): Subscription;
    lift(operator: any): Observable<unknown>;
    pipe(this: any, ...operators: any): any;
    next(nextValue: T): void;
    asObservable(): Observable<T>;
    forEach(next: (value: any) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
    toPromise(promiseCtor: any): Promise<T | undefined>;
    onError(handler: (error: unknown) => Observable<any> | void): () => boolean;
    onChanges(handler: (previous: T, current: T) => void): () => boolean;
    constructor({ check, subject, immediate }?: ValueOptions<T>, value?: T, phase?: CheckPhase);
}
export declare class DeferredValue<T> extends Value<T> implements Connectable {
    subscribable: Subscribable<any>;
    phase: CheckPhase;
    options?: ValueOptions<any> | DeferredValueOptions<any> | undefined;
    connected: boolean;
    refCount: number;
    subscription: Subscription;
    connect(): void;
    disconnect(): void;
    subscribe(observer: any): Subscription;
    constructor(subscribable: Subscribable<any>, phase?: CheckPhase, options?: ValueOptions<any> | DeferredValueOptions<any> | undefined);
}
export declare class ComputedValue extends Value<any> {
    observer: any;
    options?: ValueOptions<any> | undefined;
    dirty: boolean;
    closed: boolean;
    get value(): any;
    observe(): void;
    stop(): void;
    subscribe(observer: any): Subscription;
    constructor(observer: any, options?: ValueOptions<any> | undefined);
}
declare type Next<T> = ((param: T) => void) | NextObserver<T>;
interface Accessor<TValue, TNext> {
    next: Next<TNext>;
    value: Subscribable<TValue> | (() => TValue);
}
interface Connectable {
    connected: boolean;
    connect(): void;
    disconnect(): void;
    refCount: number;
    source: Subscribable<any>;
}
export declare class AccessorValue<TValue, TNext> extends Value<TValue> implements Connectable {
    refCount: number;
    subscription: Unsubscribable;
    subscribable: Subscribable<TValue>;
    accessor: Accessor<TValue, TNext>;
    connected: boolean;
    options?: ValueOptions<TValue> | DeferredValueOptions<TValue>;
    get value(): TValue;
    next(value: TNext): void;
    next(value: never): void;
    connect(): void;
    disconnect(): void;
    subscribe(observer: any): Subscription;
    constructor(accessor: Accessor<TValue, TNext>, options?: ValueOptions<TValue> | DeferredValueOptions<TValue>);
}
export declare function defaultFn(value: any): any;
export declare class Emitter extends EventEmitter {
    readonly __ng_emitter: boolean;
    modifier: (...params: any[]) => any;
    next(values: any): void;
    emit(values: any): void;
    call(this: any, context: any, ...args: any[]): any;
    apply(this: any, context: any, args: any[]): any;
    bind(): this;
    constructor(fn: (...params: any[]) => any);
}
export {};