/**
 * ReaderStream is a ReaderT of Most.js' Stream.
 * @since 0.9.2
 */
import { SeedValue as SV } from '@most/core/dist/combinator/loop';
import * as App from 'fp-ts/Applicative';
import * as Ap from 'fp-ts/Apply';
import * as Ch from 'fp-ts/Chain';
import { ChainRec2 } from 'fp-ts/ChainRec';
import { Compactable2 } from 'fp-ts/Compactable';
import { Either } from 'fp-ts/Either';
import { Eq } from 'fp-ts/Eq';
import * as Filterable_ from 'fp-ts/Filterable';
import * as FIO from 'fp-ts/FromIO';
import * as FR from 'fp-ts/FromReader';
import * as FT from 'fp-ts/FromTask';
import * as F from 'fp-ts/Functor';
import { IO } from 'fp-ts/IO';
import { Monad2 } from 'fp-ts/Monad';
import { Pointed2 } from 'fp-ts/Pointed';
import { Predicate } from 'fp-ts/Predicate';
import * as Re from 'fp-ts/Reader';
import { Refinement } from 'fp-ts/Refinement';
import { Separated } from 'fp-ts/Separated';
import { Task } from 'fp-ts/Task';
import * as E from './Env';
import * as FE from './FromEnv';
import * as FRe from './FromResume';
import * as FS from './FromStream';
import * as FN from './function';
import { Intersect } from './HKT';
import { MonadRec2 } from './MonadRec';
import * as O from './Option';
import * as P from './Provide';
import { SchedulerEnv } from './Scheduler';
import * as S from './Stream';
/**
 * Env is specialization of Reader<R, Resume<A>>
 * @since 0.9.2
 * @category Model
 */
export interface ReaderStream<R, A> extends Re.Reader<R, S.Stream<A>> {
}
/**
 * @since 0.9.2
 * @category Type-level
 */
export declare type RequirementsOf<A> = [A] extends [ReaderStream<infer R, any>] ? R : never;
/**
 * @since 0.9.2
 * @category Type-level
 */
export declare type ValueOf<A> = [A] extends [ReaderStream<any, infer R>] ? R : never;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const ap: <R, A>(fa: Re.Reader<R, import("@most/types").Stream<A>>) => <B>(fab: Re.Reader<R, import("@most/types").Stream<(a: A) => B>>) => Re.Reader<R, import("@most/types").Stream<B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apW: <R1, A>(fa: ReaderStream<R1, A>) => <R2, B>(fab: ReaderStream<R2, FN.Arity1<A, B>>) => ReaderStream<R1 & R2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chain: <A, R, B>(f: (a: A) => Re.Reader<R, import("@most/types").Stream<B>>) => (ma: Re.Reader<R, import("@most/types").Stream<A>>) => Re.Reader<R, import("@most/types").Stream<B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainW: <A, R1, B>(f: (a: A) => ReaderStream<R1, B>) => <R2>(ma: ReaderStream<R2, A>) => ReaderStream<R1 & R2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const switchMap: <A, R, B>(f: (a: A) => Re.Reader<R, import("@most/types").Stream<B>>) => (ma: Re.Reader<R, import("@most/types").Stream<A>>) => Re.Reader<R, import("@most/types").Stream<B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const switchMapW: <A, R1, B>(f: (a: A) => ReaderStream<R1, B>) => <R2>(ma: ReaderStream<R2, A>) => ReaderStream<R1 & R2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const switchFirst: <R1, A>(second: ReaderStream<R1, A>) => <R2, B>(first: ReaderStream<R2, B>) => ReaderStream<R1 & R2, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromReader: <R, A>(ma: Re.Reader<R, A>) => ReaderStream<R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const map: <A, B>(f: (a: A) => B) => <R>(fa: ReaderStream<R, A>) => ReaderStream<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const constant: <B>(b: B) => <R>(fa: ReaderStream<R, unknown>) => ReaderStream<R, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const of: <A, R = unknown>(a: A) => ReaderStream<R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function chainRec<A, E, B>(f: (value: A) => ReaderStream<E, Either<A, B>>): (value: A) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category URI
 */
export declare const URI = "@typed/fp/ReaderStream";
/**
 * @since 0.9.2
 * @category URI
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind2<E, A> {
        [URI]: ReaderStream<E, A>;
    }
}
declare module './HKT' {
    interface URItoVariance {
        [URI]: V<E, Contravariant>;
    }
}
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Pointed: Pointed2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Functor: F.Functor2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindTo: <N extends string>(name: N) => <E, A>(fa: ReaderStream<E, A>) => ReaderStream<E, { readonly [K in N]: A; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const flap: <A>(a: A) => <E, B>(fab: ReaderStream<E, (a: A) => B>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const tupled: <E, A>(fa: ReaderStream<E, A>) => ReaderStream<E, readonly [A]>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Apply: Ap.Apply2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apFirst: <E, B>(second: ReaderStream<E, B>) => <A>(first: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apFirstW: <E1, B>(second: ReaderStream<E1, B>) => <E2, A>(first: ReaderStream<E2, A>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apS: <N extends string, A, E, B>(name: Exclude<N, keyof A>, fb: ReaderStream<E, B>) => (fa: ReaderStream<E, A>) => ReaderStream<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSW: <N extends string, A, E1, B>(name: Exclude<N, keyof A>, fb: ReaderStream<E1, B>) => <E2>(fa: ReaderStream<E2, A>) => ReaderStream<E1 & E2, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSecond: <E, B>(second: ReaderStream<E, B>) => <A>(first: ReaderStream<E, A>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSecondW: <E1, B>(second: ReaderStream<E1, B>) => <E2, A>(first: ReaderStream<E2, A>) => ReaderStream<E1 & E2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apT: <E, B>(fb: ReaderStream<E, B>) => <A extends readonly unknown[]>(fas: ReaderStream<E, A>) => ReaderStream<E, readonly [...A, B]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apTW: <E1, B>(fb: ReaderStream<E1, B>) => <E2, A extends readonly unknown[]>(fas: ReaderStream<E2, A>) => ReaderStream<E1 & E2, readonly [...A, B]>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getApplySemigroup: <A, E>(S: import("fp-ts/Semigroup").Semigroup<A>) => import("fp-ts/Semigroup").Semigroup<ReaderStream<E, A>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSEnv: <N extends string, A, E, B>(name: Exclude<N, keyof A>, fb: E.Env<E, B>) => (fa: ReaderStream<E, A>) => ReaderStream<E, {
    readonly [K in N | keyof A]: K extends keyof A ? A[K] : B;
}>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSEnvW: <N extends string, A, E1, B>(name: Exclude<N, keyof A>, fb: E.Env<E1, B>) => <E2>(fa: ReaderStream<E2, A>) => ReaderStream<E1 & E2, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apTEnvW: <E1, B>(fb: E.Env<E1, B>) => <E2, A extends readonly unknown[]>(fas: ReaderStream<E2, A>) => ReaderStream<E1 & E2, readonly [...A, B]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apTEnv: <E, B>(fb: E.Env<E, B>) => <A extends readonly unknown[]>(fas: ReaderStream<E, A>) => ReaderStream<E, readonly [...A, B]>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Applicative: App.Applicative2<URI>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getApplicativeMonoid: <A, E>(M: import("fp-ts/Monoid").Monoid<A>) => import("fp-ts/Monoid").Monoid<ReaderStream<E, A>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Chain: Ch.Chain2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirst: <A, E, B>(f: (a: A) => ReaderStream<E, B>) => (first: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstW: <A, E1, B>(f: (a: A) => ReaderStream<E1, B>) => <E2>(first: ReaderStream<E2, A>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bind: <N extends string, A, E, B>(name: Exclude<N, keyof A>, f: (a: A) => ReaderStream<E, B>) => (ma: ReaderStream<E, A>) => ReaderStream<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindW: <N extends string, A, E1, B>(name: Exclude<N, keyof A>, f: (a: A) => ReaderStream<E1, B>) => <E2>(ma: ReaderStream<E2, A>) => ReaderStream<E1 & E2, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindEnv: <N extends string, A, E, B>(name: Exclude<N, keyof A>, f: (a: A) => E.Env<E, B>) => (ma: ReaderStream<E, A>) => ReaderStream<E, {
    readonly [K in N | keyof A]: K extends keyof A ? A[K] : B;
}>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindEnvW: <N extends string, A, E1, B>(name: Exclude<N, keyof A>, f: (a: A) => E.Env<E1, B>) => <E2>(ma: ReaderStream<E2, A>) => ReaderStream<E1 & E2, {
    readonly [K in N | keyof A]: K extends keyof A ? A[K] : B;
}>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Monad: Monad2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ChainRec: ChainRec2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const MonadRec: MonadRec2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromReader: FR.FromReader2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const ask: <R>() => ReaderStream<R, R>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asks: <R, A>(f: (r: R) => A) => ReaderStream<R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstReaderK: <A, R, B>(f: (a: A) => Re.Reader<R, B>) => (ma: ReaderStream<R, A>) => ReaderStream<R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainReaderK: <A, R, B>(f: (a: A) => Re.Reader<R, B>) => (ma: ReaderStream<R, A>) => ReaderStream<R, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromReaderK: <A extends readonly unknown[], R, B>(f: (...a: A) => Re.Reader<R, B>) => (...a: A) => ReaderStream<R, B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromResume: FRe.FromResume2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromResume: import("fp-ts/NaturalTransformation").NaturalTransformation12<"@typed/fp/Resume", "@typed/fp/ReaderStream">;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstResumeK: <A, B>(f: (value: A) => import("./Resume").Resume<B>) => <E>(hkt: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainResumeK: <A, B>(f: (value: A) => import("./Resume").Resume<B>) => <E>(hkt: ReaderStream<E, A>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromResumeK: <A extends readonly any[], B>(f: (...args: A) => import("./Resume").Resume<B>) => <E>(...args: A) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromEnv: FE.FromEnv2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromEnv: import("fp-ts/NaturalTransformation").NaturalTransformation22<"@typed/fp/Env", "@typed/fp/ReaderStream">;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainEnvK: <A, R1, B>(f: (value: A) => E.Env<R1, B>) => <R2>(hkt: ReaderStream<R2, A>) => ReaderStream<R1 & R2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstEnvK: <A, R1, B>(f: (value: A) => E.Env<R1, B>) => <R2>(hkt: ReaderStream<R2, A>) => ReaderStream<R1 & R2, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromEnvK: <A extends readonly any[], R, B>(f: (...args: A) => E.Env<R, B>) => (...args: A) => ReaderStream<R, B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromIO: FIO.FromIO2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromIO: import("fp-ts/NaturalTransformation").NaturalTransformation12<"IO", "@typed/fp/ReaderStream">;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstIOK: <A, B>(f: (a: A) => IO<B>) => <E>(first: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainIOK: <A, B>(f: (a: A) => IO<B>) => <E>(first: ReaderStream<E, A>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO<B>) => <E>(...a: A) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const Do: ReaderStream<unknown, {}>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromTask: FT.FromTask2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromTask: import("fp-ts/NaturalTransformation").NaturalTransformation12<"Task", "@typed/fp/ReaderStream">;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstTaskK: <A, B>(f: (a: A) => Task<B>) => <E>(first: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainTaskK: <A, B>(f: (a: A) => Task<B>) => <E>(first: ReaderStream<E, A>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromTaskK: <A extends readonly unknown[], B>(f: (...a: A) => Task<B>) => <E>(...a: A) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromStream: FS.FromStream2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromStream: import("fp-ts/NaturalTransformation").NaturalTransformation12<"@most/core/Stream", "@typed/fp/ReaderStream">;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstStreamK: <A, B>(f: (value: A) => S.Stream<B>) => <E>(hkt: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainStreamK: <A, B>(f: (value: A) => S.Stream<B>) => <E>(hkt: ReaderStream<E, A>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromStreamK: <A extends readonly any[], B>(f: (...args: A) => S.Stream<B>) => <E>(...args: A) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asksEnv: <E1, E2, B>(f: (e1: E1) => E.Env<E2, B>) => ReaderStream<E1 & E2, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asksIO: <E1, B>(f: (e1: E1) => IO<B>) => ReaderStream<E1, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asksTask: <E1, B>(f: (e1: E1) => Task<B>) => ReaderStream<E1, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function filter<A, B extends A>(refinement: Refinement<A, B>): <E>(rs: ReaderStream<E, A>) => ReaderStream<E, B>;
export declare function filter<A>(predicate: Predicate<A>): <E>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function merge<E1, A>(a: ReaderStream<E1, A>): <E2, B>(b: ReaderStream<E2, B>) => ReaderStream<E1 & E2, A | B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function mergeFirst<E1, A>(a: ReaderStream<E1, A>): <E2, B>(b: ReaderStream<E2, B>) => ReaderStream<E1 & E2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function mergeArray<A extends ReadonlyArray<ReaderStream<any, any>>>(streams: A): ReaderStream<Intersect<{
    readonly [K in keyof A]: RequirementsOf<A[K]>;
}>, ValueOf<A[number]>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function concatMap<A, E1>(f: (value: A) => ReaderStream<E1, A>): <E2>(rs: ReaderStream<E2, A>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const recoverWith: <E1, A>(f: (error: Error) => ReaderStream<E1, A>) => <E2>(rs: ReaderStream<E2, A>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const empty: <E>() => ReaderStream<E, never>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const never: <E>() => ReaderStream<E, never>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const periodic: <E>(period: number) => ReaderStream<E, void>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideSome: <E1>(provided: E1) => <E2, A>(rs: ReaderStream<E1 & E2, A>) => ReaderStream<E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useSome: <E1>(provided: E1) => <E2, A>(rs: ReaderStream<E1 & E2, A>) => ReaderStream<E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideAll: <E1>(provided: E1) => <A>(rs: ReaderStream<E1, A>) => ReaderStream<unknown, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useAll: <E1>(provided: E1) => <A>(rs: ReaderStream<E1, A>) => ReaderStream<unknown, A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ProvideSome: P.ProvideSome2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const UseSome: P.UseSome2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ProvideAll: P.ProvideAll2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const UseAll: P.UseAll2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Provide: P.Provide2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const askAndProvide: <E, B>(hkt: ReaderStream<E, B>) => ReaderStream<E, ReaderStream<unknown, B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const askAndUse: <E, B>(hkt: ReaderStream<E, B>) => ReaderStream<E, ReaderStream<unknown, B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideAllWith: <R, A>(provider: ReaderStream<R, A>) => <B>(hkt: ReaderStream<A, B>) => ReaderStream<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideSomeWith: <E1, A>(provider: ReaderStream<E1, A>) => P.Provider2<"@typed/fp/ReaderStream", A, E1>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useAllWith: <R, A>(provider: ReaderStream<R, A>) => <B>(hkt: ReaderStream<A, B>) => ReaderStream<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useSomeWith: <E1, A>(provider: ReaderStream<E1, A>) => P.Provider2<"@typed/fp/ReaderStream", A, E1>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideSomeWithEnv: <E, A>(env: E.Env<E, A>) => P.Provider2<"@typed/fp/ReaderStream", A, E>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideAllWithEnv: <E, A>(env: E.Env<E, A>) => <B>(hkt: ReaderStream<A, B>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useSomeWithEnv: <E, A>(env: E.Env<E, A>) => P.Provider2<"@typed/fp/ReaderStream", A, E>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useAllWithEnv: <E, A>(env: E.Env<E, A>) => <B>(hkt: ReaderStream<A, B>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const combine: <A, B, C>(f: (a: A, b: B) => C) => <E1>(rsa: ReaderStream<E1, A>) => <E2>(rsb: ReaderStream<E2, B>) => ReaderStream<E1 & E2, C>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const combineAll: <A extends readonly ReaderStream<any, any>[]>(...rss: A) => ReaderStream<Intersect<{ readonly [K in keyof A]: RequirementsOf<A[K]>; }, unknown>, { readonly [K_1 in keyof A]: ValueOf<A[K_1]>; }>;
/**
 * @since 0.13.2
 * @category Combinator
 */
export declare const struct: <Props extends Readonly<Record<string, ReaderStream<any, any>>>>(props: Props) => ReaderStream<unknown, { readonly [K in keyof Props]: ValueOf<Props[K]>; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const withStream: <A, B>(f: (stream: S.Stream<A>) => B) => <E>(rs: ReaderStream<E, A>) => Re.Reader<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const tap: <A>(f: (value: A) => any) => <E>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const take: (n: number) => <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const skip: (n: number) => <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const startWith: <A>(value: A) => <E, B>(stream: ReaderStream<E, B>) => ReaderStream<E, A | B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const exhaustLatest: <E1, E2, A>(rs: ReaderStream<E1, ReaderStream<E2, A>>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const exhaustMapLatest: <A, E1, B>(f: (value: A) => ReaderStream<E1, B>) => <E2>(rs: ReaderStream<E2, A>) => ReaderStream<E1 & E2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const exhaustLatestEnv: <E1, A>(env: E.Env<E1, A>) => <E2, B>(rs: ReaderStream<E2, B>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const exhaustMapLatestEnv: <A, E1, B>(f: (value: A) => E.Env<E1, B>) => <E2>(rs: ReaderStream<E2, A>) => ReaderStream<E1 & E2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const onDispose: (disposable: S.Disposable) => <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const collectEvents: (scheduler: S.Scheduler) => <E, A>(rs: ReaderStream<E, A>) => Re.Reader<E, Promise<readonly A[]>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const now: <A>(x: A) => ReaderStream<unknown, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const at: <A>(t: number, x: A) => ReaderStream<unknown, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const scan: <A, B>(f: (acc: A, value: B) => A, seed: A) => <E>(rs: ReaderStream<E, B>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const skipRepeatsWith: <A>(Eq: Eq<A>) => <E>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const skipRepeats: <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const compact: <E, A>(rs: ReaderStream<E, O.Option<A>>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const continueWith: <E1, A>(f: () => ReaderStream<E1, A>) => <E2, B>(rs: ReaderStream<E2, A>) => ReaderStream<E1 & E2, A | B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const debounce: (delay: S.Time) => <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const delay: (delay: S.Time) => <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const join: <E1, E2, A>(rs: ReaderStream<E1, ReaderStream<E2, A>>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const during: <E1, E2>(timeWindow: ReaderStream<E1, ReaderStream<E2, any>>) => <E3, A>(values: ReaderStream<E3, A>) => ReaderStream<E1 & E2 & E3, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const filterMap: <A, B>(f: (a: A) => O.Option<B>) => <E>(fa: ReaderStream<E, A>) => ReaderStream<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const loop: <A, B, C>(f: (a: A, b: B) => SV<A, C>, seed: A) => <E>(fa: ReaderStream<E, B>) => ReaderStream<E, C>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const mergeConcurrently: (concurrency: number) => <E1, E2, A>(rs: ReaderStream<E1, ReaderStream<E2, A>>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const multicast: <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const partition: <A>(predicate: Predicate<A>) => <E>(fa: ReaderStream<E, A>) => Separated<ReaderStream<E, A>, ReaderStream<E, A>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const partitionMap: <A, B, C>(f: (a: A) => Either<B, C>) => <E>(fa: ReaderStream<E, A>) => Separated<ReaderStream<E, B>, ReaderStream<E, C>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const race: <E1, A>(second: ReaderStream<E1, A>) => <E2, B>(first: ReaderStream<E2, B>) => ReaderStream<E1 & E2, A | B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const separate: <E, A, B>(rs: ReaderStream<E, Either<A, B>>) => Separated<ReaderStream<E, A>, ReaderStream<E, B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const since: <E1>(timeWindow: ReaderStream<E1, any>) => <E2, A>(values: ReaderStream<E2, A>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const skipAfter: <A>(p: (a: A) => boolean) => <E>(s: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const skipWhile: <A>(p: (a: A) => boolean) => <E>(s: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const slice: (skip: number, take: number) => <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const switchLatest: <E1, E2, A>(rs: ReaderStream<E1, ReaderStream<E2, A>>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const takeWhile: <A>(p: (a: A) => boolean) => <E>(s: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const throttle: (period: number) => <E, A>(s: ReaderStream<E, A>) => ReaderStream<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const throwError: <E>(e: Error) => ReaderStream<E, never>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const until: <E1>(timeWindow: ReaderStream<E1, any>) => <E2, A>(values: ReaderStream<E2, A>) => ReaderStream<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const zero: <A>() => ReaderStream<unknown, A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Filterable: Filterable_.Filterable2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Compactable: Compactable2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const keyed: <A>(Eq: Eq<A>) => <E>(rs: ReaderStream<E, readonly A[]>) => ReaderStream<E, readonly S.Stream<A>[]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const mergeMapWhen: <V>(Eq?: Eq<V>) => <E1, A>(f: (value: V) => ReaderStream<E1, A>) => <E2>(values: ReaderStream<E2, readonly V[]>) => ReaderStream<E1 & E2, readonly A[]>;
/**
 * Listens to the next value of a stream.
 */
/**
 * @since 0.9.2
 * @category Natural Transformation
 */
export declare const toEnv: <E, A>(rs: ReaderStream<E, A>) => E.Env<E & SchedulerEnv, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const hold: <E, A>(rs: ReaderStream<E, A>) => ReaderStream<E, A>;
//# sourceMappingURL=ReaderStream.d.ts.map