export declare class UnhandledObservableError extends Error {
    constructor(cause?: unknown);
}
export type Next<T> = (t: T) => void;
export interface Observer<T> {
    next: Next<T>;
    error<E extends Error>(e: E): void;
    complete(): void;
}
export interface Subscription {
    unsubscribe(): void;
}
export interface Subscribable<T> {
    subscribe(subscriber: Observer<T> | Next<T>): Subscription;
}
export interface Observable<T> extends Subscribable<T> {
    /**
     * Transform a stream of values passing it through
     * a mapping function
     */
    map<U>(f: (t: T) => U): Observable<U>;
    /**
     * Create a new stream only for values that match a
     * certain filtering function
     */
    filter(f: (t: T) => boolean): Observable<T>;
}
/**
 * A Subject is a special type of observable tha allows values to be
 * multicasted to many observers.
 *
 * We use the name Subject as is the terminology used by rxjs
 * https://rxjs.dev/guide/subject
 */
export declare class Subject<T> implements Observer<T>, Subscribable<T> {
    private subscribers;
    private cleanup;
    next(t: T): void;
    error(e: Error): void;
    complete(): void;
    subscribe(next: Observer<T> | Next<T>): Subscription;
}
type ObservableInput<T> = PromiseLike<T> | Iterable<T> | AsyncIterable<T> | Subscribable<T>;
declare function from<T>(input: ObservableInput<T>): Observable<T>;
declare function map<T, U>(o: Subscribable<T>, f: (t: T) => U): Subscribable<U>;
declare function filter<T>(o: Subscribable<T>, f: (t: T) => boolean): Subscribable<T>;
declare function of<T>(...values: T[]): Observable<T>;
declare function is<T>(x: unknown): x is Observable<T>;
/**
 * Utility function to return a value on an interval.
 * This is a useful observable to build new observables from
 */
export declare function interval(periodMs: number): Observable<number>;
export declare const Observable: {
    of: typeof of;
    from: typeof from;
    is: typeof is;
    map: typeof map;
    filter: typeof filter;
    interval: typeof interval;
};
export {};