import { Observer } from '../objects/observable';
import { SealedPartial, SealedState } from '../results/sealed';
interface StreamResponse<T> {
    response: T;
    responseTime: number;
}
interface StreamState<S, V = any> extends SealedState<V> {
    failure: (error: any) => V;
    loading: () => V;
    success: (state: StreamResponse<S>) => V;
}
export declare class Stream<S, V = any> extends SealedPartial<V, StreamResponse<S>, StreamState<S, V>> {
    static loading(): Stream<any>;
    static success<S>(value: StreamResponse<S>): Stream<S>;
    static failure(error: any): Stream<any>;
}
declare class StreamStatus<T, E = any> {
    readonly isLoading: boolean;
    readonly isSuccessful: boolean;
    readonly isError: boolean;
    readonly value?: T | undefined;
    readonly error?: E | undefined;
    private constructor();
    static loading(): StreamStatus<any, any>;
    static successful<T>(value?: T): StreamStatus<T, any>;
    static error<E = any>(error?: E): StreamStatus<any, E>;
}
type StreamObserver<T> = (observer: Observer<Stream<T>>) => Unsubscription;
interface StreamSubscription<T> {
    subscribe: StreamObserver<T>;
}
interface StreamStateSubscription<T, V> {
    subscribe: (state: Partial<StreamState<T, V>>) => Unsubscription;
}
interface StreamStatusSubscription<T, E = any> {
    subscribe: (observer: (status: StreamStatus<T, E>) => void) => Unsubscription;
}
export declare function stream<T>(promise: Promise<T>): StreamSubscription<T>;
export declare function streamValue<T, V = any>(promise: Promise<T>): StreamStateSubscription<T, V>;
export declare function streamStatus<T, E = any>(promise: Promise<T>): StreamStatusSubscription<T, E>;
export {};