import { Applicative1 } from 'fp-ts/Applicative';
import { Apply1 } from 'fp-ts/Apply';
import { Chain1 } from 'fp-ts/Chain';
import { Endomorphism } from 'fp-ts/Endomorphism';
import { Eq } from 'fp-ts/Eq';
import { FromIO1 } from 'fp-ts/FromIO';
import { Lazy } from 'fp-ts/function';
import { Functor1 } from 'fp-ts/Functor';
import { Monad1 } from 'fp-ts/Monad';
import { Option } from 'fp-ts/Option';
import { Pointed1 } from 'fp-ts/Pointed';
import { ReadonlyRecord } from 'fp-ts/ReadonlyRecord';
import { Lens } from 'monocle-ts/Lens';
import { Observable } from 'rxjs';

/** @since 1.0.0 */

/**
 * @since 1.0.0
 * @category Model
 */
interface ReadonlyAtom<T> extends Observable<T> {
    get: () => T;
}
/**
 * @since 1.0.0
 * @category Refinements
 */
declare const isReadonlyAtom: <T>(fa: unknown) => fa is ReadonlyAtom<T>;
/**
 * @since 1.0.0
 * @category Constructors
 */
declare const make: <T>(evaluate: (prev: Option<T>) => T, source: Observable<T>, eq: Eq<T>) => ReadonlyAtom<T>;
/**
 * @since 1.0.0
 * @category Constructors
 */
declare const fromIO: FromIO1<URI>['fromIO'];
/**
 * @since 3.0.0
 * @category Constructors
 */
declare const getOf: <A>(eq: Eq<A>) => (a: A) => ReadonlyAtom<A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
declare const of: Pointed1<URI>['of'];
/**
 * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>)
 * => F<B>` whose argument and return types use the type constructor `F` to
 * represent some computational context.
 *
 * @since 1.0.0
 * @category Functor
 */
declare const map: <A, B>(f: (a: A) => B) => (fa: ReadonlyAtom<A>) => ReadonlyAtom<B>;
/**
 * Apply a function to an argument under a type constructor.
 *
 * @since 1.1.0
 * @category Apply
 */
declare const ap: <A>(fa: ReadonlyAtom<A>) => <B>(fab: ReadonlyAtom<(a: A) => B>) => ReadonlyAtom<B>;
/**
 * Composes computations in sequence, using the return value of one computation
 * to determine the next computation.
 *
 * @since 3.0.0
 * @category Sequencing
 */
declare const chain: <A, B>(f: (a: A) => ReadonlyAtom<B>) => (ma: ReadonlyAtom<A>) => ReadonlyAtom<B>;
/**
 * @since 3.0.0
 * @category Sequencing
 */
declare const flatten: <A>(mma: ReadonlyAtom<ReadonlyAtom<A>>) => ReadonlyAtom<A>;
/**
 * Compose a `ReadonlyAtom` with a `Lens`.
 *
 * @since 1.0.0
 * @category Compositions
 */
declare const lens: <A, B>(ab: Lens<A, B>, eq?: Eq<B>) => (a: ReadonlyAtom<A>) => ReadonlyAtom<B>;
/**
 * Return a `ReadonlyAtom` from a `ReadonlyAtom` and prop.
 *
 * @since 1.0.0
 * @category Compositions
 */
declare const prop: <A, P extends keyof A>(prop: P, eq?: Eq<A[P]>) => (sa: ReadonlyAtom<A>) => ReadonlyAtom<A[P]>;
/**
 * Return a `ReadonlyAtomOption` from a `ReadonlyAtom` focused on a key of a
 * `ReadonlyRecord`. If you set `None` it won't change the `ReadonlyRecord`.
 *
 * @since 1.0.0
 * @category Compositions
 */
declare const key: <A>(key: string, eq?: Eq<A>) => (sa: ReadonlyAtom<ReadonlyRecord<string, A>>) => ReadonlyAtom<Option<A>>;
/**
 * Return a `ReadonlyAtomOption` from a `ReadonlyAtom` focused on an index of a
 * `ReadonlyArray`. If you set `None` it won't change the `ReadonlyArray`. If
 * the index is out of bound, it won't change the `ReadonlyArray` no matter what
 * you pass as `Option`.
 *
 * @since 1.0.0
 * @category Compositions
 */
declare const index: <A>(index: number, eq?: Eq<A>) => (sa: ReadonlyAtom<ReadonlyArray<A>>) => ReadonlyAtom<Option<A>>;
/**
 * Return a `ReadonlyAtom` from a `ReadonlyAtom` with new Eq instance.
 *
 * @since 1.1.0
 * @category Utils
 */
declare const distinct: <A>(eq: Eq<A>) => Endomorphism<ReadonlyAtom<A>>;
/**
 * Return a `ReadonlyAtom` from a `ReadonlyAtomOption` replacing `None` with the
 * given value.
 *
 * @since 1.0.0
 * @category Utils
 */
declare const withDefault: <A>(d: Lazy<A>, eq?: Eq<A>) => (sa: ReadonlyAtom<Option<A>>) => ReadonlyAtom<A>;
/**
 * @since 1.0.0
 * @category Instances
 */
declare const URI = "ReadonlyAtom";
/**
 * @since 1.0.0
 * @category Instances
 */
type URI = typeof URI;
declare module 'fp-ts/lib/HKT' {
    interface URItoKind<A> {
        readonly [URI]: ReadonlyAtom<A>;
    }
}
/**
 * @since 1.0.0
 * @category Instances
 */
declare const Functor: Functor1<URI>;
/**
 * @since 1.0.0
 * @category Instances
 */
declare const Pointed: Pointed1<URI>;
/**
 * @since 1.0.0
 * @category Instances
 */
declare const FromIO: FromIO1<URI>;
/**
 * @since 1.1.0
 * @category Instances
 */
declare const Apply: Apply1<URI>;
/**
 * @since 1.1.0
 * @category Instances
 */
declare const Applicative: Applicative1<URI>;
/**
 * @since 3.0.0
 * @category Instances
 */
declare const Chain: Chain1<URI>;
/**
 * @since 3.0.0
 * @category Instances
 */
declare const Monad: Monad1<URI>;

type ReadonlyAtom$1_ReadonlyAtom<T> = ReadonlyAtom<T>;
declare const ReadonlyAtom$1_isReadonlyAtom: typeof isReadonlyAtom;
declare const ReadonlyAtom$1_make: typeof make;
declare const ReadonlyAtom$1_fromIO: typeof fromIO;
declare const ReadonlyAtom$1_getOf: typeof getOf;
declare const ReadonlyAtom$1_of: typeof of;
declare const ReadonlyAtom$1_map: typeof map;
declare const ReadonlyAtom$1_ap: typeof ap;
declare const ReadonlyAtom$1_chain: typeof chain;
declare const ReadonlyAtom$1_flatten: typeof flatten;
declare const ReadonlyAtom$1_lens: typeof lens;
declare const ReadonlyAtom$1_prop: typeof prop;
declare const ReadonlyAtom$1_key: typeof key;
declare const ReadonlyAtom$1_index: typeof index;
declare const ReadonlyAtom$1_distinct: typeof distinct;
declare const ReadonlyAtom$1_withDefault: typeof withDefault;
type ReadonlyAtom$1_URI = URI;
declare const ReadonlyAtom$1_Functor: typeof Functor;
declare const ReadonlyAtom$1_Pointed: typeof Pointed;
declare const ReadonlyAtom$1_FromIO: typeof FromIO;
declare const ReadonlyAtom$1_Apply: typeof Apply;
declare const ReadonlyAtom$1_Applicative: typeof Applicative;
declare const ReadonlyAtom$1_Chain: typeof Chain;
declare const ReadonlyAtom$1_Monad: typeof Monad;
declare namespace ReadonlyAtom$1 {
  export {
    ReadonlyAtom$1_ReadonlyAtom as ReadonlyAtom,
    ReadonlyAtom$1_isReadonlyAtom as isReadonlyAtom,
    ReadonlyAtom$1_make as make,
    ReadonlyAtom$1_fromIO as fromIO,
    ReadonlyAtom$1_getOf as getOf,
    ReadonlyAtom$1_of as of,
    ReadonlyAtom$1_map as map,
    ReadonlyAtom$1_ap as ap,
    ReadonlyAtom$1_chain as chain,
    ReadonlyAtom$1_flatten as flatten,
    ReadonlyAtom$1_lens as lens,
    ReadonlyAtom$1_prop as prop,
    ReadonlyAtom$1_key as key,
    ReadonlyAtom$1_index as index,
    ReadonlyAtom$1_distinct as distinct,
    ReadonlyAtom$1_withDefault as withDefault,
    ReadonlyAtom$1_URI as URI,
    ReadonlyAtom$1_Functor as Functor,
    ReadonlyAtom$1_Pointed as Pointed,
    ReadonlyAtom$1_FromIO as FromIO,
    ReadonlyAtom$1_Apply as Apply,
    ReadonlyAtom$1_Applicative as Applicative,
    ReadonlyAtom$1_Chain as Chain,
    ReadonlyAtom$1_Monad as Monad,
  };
}

export { Apply as A, Chain as C, Functor as F, Monad as M, Pointed as P, ReadonlyAtom$1 as R, URI as U, ReadonlyAtom as a, map as b, ap as c, chain as d, flatten as e, fromIO as f, getOf as g, index as h, isReadonlyAtom as i, distinct as j, key as k, lens as l, make as m, FromIO as n, of as o, prop as p, Applicative as q, withDefault as w };