/**
 * `Ref` is an abstraction for managing data-driven applications using [Env](./Env.ts.md).
 * @since 0.11.0
 */
import * as Ap from 'fp-ts/Apply';
import { Functor3 } from 'fp-ts/Functor';
import { IO } from 'fp-ts/IO';
import { Profunctor3 } from 'fp-ts/Profunctor';
import { Reader } from 'fp-ts/Reader';
import { Semigroupoid3 } from 'fp-ts/Semigroupoid';
import { Task } from 'fp-ts/Task';
import { U } from 'ts-toolbelt';
import * as E from './Env';
import * as FKV from './FromKV';
import { Intersect } from './HKT';
import * as KV from './KV';
import * as O from './Option';
import * as P from './Provide';
import * as RS from './ReaderStream';
import { Resume } from './Resume';
/**
 * @since 0.11.0
 * @category Model
 */
export interface Ref<E, I, O = I> {
    readonly get: E.Env<E, O>;
    readonly has: E.Env<E, boolean>;
    readonly set: (input: I) => E.Env<E, O>;
    readonly update: <E2>(f: (value: O) => E.Env<E2, I>) => E.Env<E & E2, O>;
    readonly remove: E.Env<E, O.Option<O>>;
    readonly values: RS.ReaderStream<E, O.Option<O>>;
}
/**
 * @since 0.11.0
 * @category Type-level
 */
export declare type RequirementsOf<A> = [A] extends [Ref<infer R, any, any>] ? R : never;
/**
 * @since 0.11.0
 * @category Type-level
 */
export declare type InputOf<A> = [A] extends [Ref<any, infer R, any>] ? R : never;
/**
 * @since 0.11.0
 * @category Type-level
 */
export declare type OutputOf<A> = [A] extends [Ref<any, any, infer R>] ? R : never;
/**
 * @since 0.11.0
 * @category URI
 */
export declare const URI = "@typed/fp/Ref";
/**
 * @since 0.11.0
 * @category URI
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind2<E, A> {
        [URI]: Ref<E, A>;
    }
    interface URItoKind3<R, E, A> {
        [URI]: Ref<R, E, A>;
    }
}
declare module './HKT' {
    interface URItoVariance {
        [URI]: V<R, Contravariant>;
    }
}
/**
 * @since 0.11.0
 * @category Constructor
 */
export declare const fromKV: <K, E, A>(kv: KV.KV<K, E, A>) => Ref<E & KV.Env, A, A> & KV.KV<K, E, A>;
/**
 * @since 0.11.0
 * @category Constructor
 */
export declare const kv: <E, A, K = symbol>(initial: E.Env<E, A>, options?: KV.Options<K, A> | undefined) => Ref<E & KV.Env, A, A> & KV.KV<K, E, A>;
/**
 * @since 0.12.0
 * @category Instance Constructor
 */
export declare const FromKV: FKV.FromKV2<URI, KV.Env>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const map: <A, B>(f: (value: A) => B) => <E, I>(ref: Ref<E, I, A>) => Ref<E, I, B>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const Functor: Functor3<URI>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const local: <A, B>(f: (value: A) => B) => <E, C>(ref: Ref<E, B, C>) => Ref<E, A, C>;
/**
 * @since 0.12.2
 * @category Combinator
 */
export declare const localE: <A, E1, B>(f: (value: A) => E.Env<E1, B>) => <E2, C>(ref: Ref<E2, B, C>) => Ref<E1 & E2, A, C>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const promap: <B, A, C, D>(f: (value: B) => A, g: (value: C) => D) => <E>(ref: Ref<E, A, C>) => Ref<E, B, D>;
/**
 * @since 0.12.2
 * @category Combinator
 */
export declare const promapE: <B, E1, A, C, E2, D>(f: (value: B) => E.Env<E1, A>, g: (value: C) => E.Env<E2, D>) => <E3>(ref: Ref<E3, A, C>) => Ref<E1 & E2 & E3, B, D>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const Profunctor: Profunctor3<URI>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const ap: <E1, I, A>(fa: Ref<E1, I, A>) => <E2, B>(fab: Ref<E2, I, (value: A) => B>) => Ref<E1 & E2, I, B>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const Apply: Ap.Apply3<URI>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apFirst: <R, E, B>(second: Ref<R, E, B>) => <A>(first: Ref<R, E, A>) => Ref<R, E, A>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apFirstW: <R1, E, B>(second: Ref<R1, E, B>) => <R2, A>(first: Ref<R2, E, A>) => Ref<R1 & R2, E, A>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apS: <N extends string, A, R, E, B>(name: Exclude<N, keyof A>, fb: Ref<R, E, B>) => (fa: Ref<R, E, A>) => Ref<R, E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apSW: <N extends string, A, R1, E, B>(name: Exclude<N, keyof A>, fb: Ref<R1, E, B>) => <R2>(fa: Ref<R2, E, A>) => Ref<R1 & R2, E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apSecond: <R, E, B>(second: Ref<R, E, B>) => <A>(first: Ref<R, E, A>) => Ref<R, E, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apSecondW: <R1, E, B>(second: Ref<R1, E, B>) => <R2, A>(first: Ref<R2, E, A>) => Ref<R1 & R2, E, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apT: <R, E, B>(fb: Ref<R, E, B>) => <A extends readonly unknown[]>(fas: Ref<R, E, A>) => Ref<R, E, readonly [...A, B]>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const apTW: <R1, E, B>(fb: Ref<R1, E, B>) => <R2, A extends readonly unknown[]>(fas: Ref<R2, E, A>) => Ref<R1 & R2, E, readonly [...A, B]>;
/**
 * @since 0.11.0
 * @category Typeclass Constructor
 */
export declare const getApplySemigroup: <A, R, E>(S: import("fp-ts/Semigroup").Semigroup<A>) => import("fp-ts/Semigroup").Semigroup<Ref<R, E, A>>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const compose: <E2, A, O>(second: Ref<E2, A, O>) => <E1, I>(first: Ref<E1, I, A>) => Ref<E1 & E2, I, O>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const Semigroupoid: Semigroupoid3<URI>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const provideSome: <E1>(provided: E1) => <E2, A, B>(ref: Ref<E1 & E2, A, B>) => Ref<E2, A, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const provideAll: <E>(provided: E) => <A, B>(ref: Ref<E, A, B>) => Ref<unknown, A, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const useSome: <E1>(provided: E1) => <E2, A, B>(ref: Ref<E1 & E2, A, B>) => Ref<E2, A, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const useAll: <E1>(provided: E1) => <A, B>(ref: Ref<E1, A, B>) => Ref<unknown, A, B>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const UseSome: P.UseSome3<URI>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const UseAll: P.UseAll3<URI>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const ProvideSome: P.ProvideSome3<URI>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const ProvideAll: P.ProvideAll3<URI>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const Provide: P.Provide3<URI>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainEnvK<A, E1, B>(f: (value: A) => E.Env<E1, B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E1 & E2, I, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainFirstEnvK<A, E1, B>(f: (value: A) => E.Env<E1, B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E1 & E2, I, A>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainIOK<A, B>(f: (value: A) => IO<B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E2, I, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainFirstIOK<A, B>(f: (value: A) => IO<B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E2, I, A>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainReaderK<A, E1, B>(f: (value: A) => Reader<E1, B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E1 & E2, I, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainFirstReaderK<A, E1, B>(f: (value: A) => Reader<E1, B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E1 & E2, I, A>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainResumeK<A, B>(f: (value: A) => Resume<B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E2, I, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainFirstResumeK<A, B>(f: (value: A) => Resume<B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E2, I, A>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainTaskK<A, B>(f: (value: A) => Task<B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E2, I, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function chainFirstTaskK<A, B>(f: (value: A) => Task<B>): <E2, I>(ref: Ref<E2, I, A>) => Ref<E2, I, A>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function struct<S extends AnyRefStruct>(properties: S): Ref<RefStructEnv<S>, RefStructInput<S>, RefStructOutput<S>>;
declare type AnyRefStruct = Readonly<Record<string, Ref<any, any, any>>>;
declare type RefStructEnv<A extends AnyRefStruct> = Intersect<U.ListOf<RequirementsOf<A[keyof A]>>>;
declare type RefStructInput<S extends AnyRefStruct> = {
    readonly [K in keyof S]: InputOf<S[K]>;
};
declare type RefStructOutput<S extends AnyRefStruct> = {
    readonly [K in keyof S]: OutputOf<S[K]>;
};
export {};
//# sourceMappingURL=Ref.d.ts.map