import { ComponentType, ReactElement } from "react";
import { EnumeratorLike } from "../collections.js";
import { DispatcherLike, FlowableLike, MulticastObservableLike, ObservableLike, PauseableLike, PauseableObservableLike, StreamOf, StreamableLike } from "../concurrent.js";
import { EventSourceLike } from "../events.js";
import { Factory, Function1, Optional, SideEffect } from "../functions.js";
import { BackpressureStrategy, DisposableLike } from "../utils.js";
interface ReactModule {
    createComponent<TProps>(fn: Function1<MulticastObservableLike<TProps>, ObservableLike<ReactElement>>, options?: {
        readonly priority?: 1 | 2 | 3 | 4 | 5;
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly capacity?: number;
    }): ComponentType<TProps>;
    useDispatcher<TReq>(dispatcher: Optional<DispatcherLike<TReq>>): {
        enqueue: Function1<TReq, boolean>;
        complete: SideEffect;
    };
    /**
     */
    useDisposable<TDisposable extends DisposableLike>(factory: () => Optional<TDisposable>, deps: readonly unknown[]): Optional<TDisposable>;
    /**
     */
    useEnumerator<T>(enumerator: Optional<EnumeratorLike<T>>): {
        move: Factory<boolean>;
        hasCurrent: boolean;
        current: T;
    };
    /**
     */
    useFlow<T>(flowable: FlowableLike<T>, options?: {
        readonly priority?: 1 | 2 | 3 | 4 | 5;
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly capacity?: number;
        readonly replay?: number;
    }): Optional<PauseableObservableLike<T>>;
    useFlow<T>(factory: Factory<FlowableLike<T>>, dep: readonly unknown[], options?: {
        readonly priority?: 1 | 2 | 3 | 4 | 5;
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly capacity?: number;
        readonly replay?: number;
    }): Optional<PauseableObservableLike<T>>;
    /**
     */
    useListen<T>(eventSource: Optional<EventSourceLike<T>>): Optional<T>;
    useListen<T>(factory: Factory<Optional<EventSourceLike<T>>>, deps: readonly unknown[]): Optional<T>;
    /**
     */
    useObserve<T>(observable: Optional<ObservableLike<T>>, options?: {
        readonly priority?: 1 | 2 | 3 | 4 | 5;
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly capacity?: number;
    }): Optional<T>;
    useObserve<T>(factory: Factory<Optional<ObservableLike<T>>>, deps: readonly unknown[], options?: {
        readonly priority?: 1 | 2 | 3 | 4 | 5;
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly capacity?: number;
    }): Optional<T>;
    /**
     */
    usePauseable(pauseable: Optional<PauseableLike>): {
        isPaused: boolean;
        pause: SideEffect;
        resume: SideEffect;
    };
    /**
     */
    useStream<TStreamable extends StreamableLike>(streamable: TStreamable, options?: {
        readonly priority?: 1 | 2 | 3 | 4 | 5;
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly capacity?: number;
        readonly replay?: number;
    }): Optional<StreamOf<TStreamable>>;
    useStream<TStreamable extends StreamableLike>(factory: Factory<TStreamable>, dep: readonly unknown[], options?: {
        readonly priority?: 1 | 2 | 3 | 4 | 5;
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly capacity?: number;
        readonly replay?: number;
    }): Optional<StreamOf<TStreamable>>;
}
type Signature = ReactModule;
export declare const createComponent: Signature["createComponent"];
export declare const useDispatcher: Signature["useDispatcher"];
export declare const useDisposable: Signature["useDisposable"];
export declare const useEnumerator: Signature["useEnumerator"];
export declare const useListen: Signature["useListen"];
export declare const useObserve: Signature["useObserve"];
export declare const usePauseable: Signature["usePauseable"];
export declare const useStream: Signature["useStream"];
export declare const useFlow: Signature["useFlow"];
export {};