import { Disposable } from '@most/types';
import * as O from 'fp-ts/Option';
import * as E from './Env';
import { Eq } from './Eq';
import * as KV from './KV';
import * as RS from './ReaderStream';
import * as Ref from './Ref';
import { SchedulerEnv } from './Scheduler';
import * as S from './Stream';
/**
 * Use Refs to check if a value has changed between invocations
 * @since 0.11.0
 * @category Constructor
 */
export declare const defaultOptionRef: <A>() => Ref.Ref<KV.Env, O.Option<A>, O.Option<A>> & KV.KV<symbol, unknown, O.Option<A>>;
/**
 * Use Refs to check if a value has changed between invocations
 * @since 0.11.0
 * @category Combinator
 */
export declare function useEqWith<E, A = void>(ref: Ref.Ref<E, O.Option<A>>): (Eq?: Eq<A>, initial?: boolean) => (value: A) => E.Env<E, boolean>;
/**
 * Use Refs to check if a value has changed between invocations
 * @since 0.11.0
 * @category Combinator
 */
export declare const useEq: <A>(Eq?: Eq<A>, initial?: boolean) => (value: A) => E.Env<KV.Env, boolean>;
/**
 * @since 0.11.0
 * @category Options
 */
export declare type UseMemoWithOptions<E1, A, E2, B> = {
    readonly currentValue: Ref.Ref<E1, O.Option<A>>;
    readonly changed: Ref.Ref<E2, O.Option<B>>;
};
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useMemoWith: <E1, A, E2, B>(options: UseMemoWithOptions<E1, A, E2, B>) => <E3>(env: E.Env<E3, A>, Eq?: Eq<B>) => (value: B) => E.Env<E1 & E2 & E3, A>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useMemo: <E, A, B>(env: E.Env<E, A>, Eq?: Eq<B>) => (value: B) => E.Env<KV.Env & E, A>;
/**
 * @since 0.11.0
 * @category Options
 */
export declare type UseDisposableWithOptions<E1, E2, A> = {
    readonly disposable: Ref.Ref<E1, Disposable>;
    readonly changed: Ref.Ref<E2, O.Option<A>>;
};
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useDisposableWith: <E1, E2, A = void>(options: UseDisposableWithOptions<E1, E2, A>) => (Eq?: Eq<A>, switchLatest?: boolean) => (f: () => Disposable, value: A) => E.Env<E1 & E2 & KV.Env, Disposable>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useDisposable: <A>(Eq?: Eq<A>, switchLatest?: boolean) => (f: () => Disposable, value: A) => E.Env<KV.Env, Disposable>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useEffectWith: <E1, E2, A = void>(options: UseDisposableWithOptions<E1, E2, A>) => (Eq?: Eq<A>, switchLatest?: boolean) => <E>(env: E.Env<E, any>, value: A) => E.Env<E1 & E2 & KV.Env & E & SchedulerEnv, Disposable>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useWithPrevious: <E, A>(ref: Ref.Ref<E, O.Option<A>, O.Option<A>>) => <B>(f: (previous: O.Option<A>, value: A) => B, value: A) => E.Env<E, B>;
/**
 * Helps you to convert a Kliesli arrow of an Env into a function to
 * a Disposable. Useful for UIs where you need to provide onClick={fn}
 * style handlers.
 * @since 0.11.0
 * @category Use
 */
export declare function useEnvK<A extends ReadonlyArray<any>, E1, B, E2>(f: (...args: A) => E.Env<E1, B>, onValue?: (value: B) => E.Env<E2, any>): E.Env<E1 & E2 & KV.Env, (...args: A) => Disposable>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const bindEnvK: <N extends string, A, Args extends readonly any[], E1, B, E2>(name: Exclude<N, keyof A>, f: (...args: Args) => E.Env<E1, B>, onValue?: ((value: B) => E.Env<E2, any>) | undefined) => <E3>(ma: E.Env<E3, A>) => E.Env<E1 & E2 & E3 & KV.Env, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : () => Disposable; }>;
/**
 * @since 0.11.0
 * @category Options
 */
export declare type UseReaderStreamWithOptions<E1, A, E2, E3, B> = {
    readonly value: Ref.Ref<E1, O.Option<A>>;
} & UseDisposableWithOptions<E2, E3, B>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useReaderStreamWith: <E1, A, E2, E3, B = void>(options: UseReaderStreamWithOptions<E1, A, E2, E3, B>) => (Eq?: Eq<B>) => <E4, C extends A>(rs: RS.ReaderStream<E4, C>, dep: B) => E.Env<E1 & E2 & E3 & E4 & SchedulerEnv & KV.Env, O.Option<C>>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useReaderStream: <A = void>(Eq?: Eq<A>) => <E4, C extends any>(rs: RS.ReaderStream<E4, C>, dep: A) => E.Env<KV.Env & E4 & SchedulerEnv, O.Option<C>>;
/**
 * @since 0.11.0
 * @category Options
 */
export declare type UseStreamWithOptions<E1, A, E2, E3, B> = UseReaderStreamWithOptions<E1, A, E2, E3, B>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useStreamWith: <E1, A, E2, E3, B>(options: UseStreamWithOptions<E1, A, E2, E3, B>) => (Eq?: Eq<B>) => (stream: S.Stream<A>, dep: B) => E.Env<E1 & E2 & E3 & SchedulerEnv & KV.Env, O.Option<A>>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useStream: <A = void>(Eq?: Eq<A>) => <B>(stream: S.Stream<B>, dep: A) => E.Env<KV.Env & SchedulerEnv, O.Option<B>>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useKVStream: <A, E1, B>(f: (value: A) => RS.ReaderStream<E1, B>, Eq: Eq<A>) => <E2>(stream: RS.ReaderStream<E2, readonly A[]>) => RS.ReaderStream<E1 & E2 & KV.Env, readonly B[]>;
/**
 * @since 0.11.0
 * @category Use
 */
export declare const useKVs: <A, E1, B>(f: (value: A) => E.Env<E1, B>, Eq: Eq<A>) => <E2>(stream: RS.ReaderStream<E2, readonly A[]>) => RS.ReaderStream<E1 & KV.Env & E2, readonly B[]>;
//# sourceMappingURL=Use.d.ts.map