import { Eq } from 'fp-ts/Eq';
import { Option } from 'fp-ts/Option';
import { Subject, Observable } from 'rxjs';
import { a as Atom } from './Atom-b4714405.js';
import { a as ReadonlyAtom } from './ReadonlyAtom-7cbf97ea.js';

/** @since 1.0.0 */

/**
 * @since 1.0.0
 * @category Classes
 */
declare class Mim<T> extends Subject<T> {
    /** @since 3.0.0 */
    readonly evaluate: (prev: Option<T>) => T;
    /** @since 3.0.0 */
    readonly source$: Observable<T>;
    /** @since 1.0.0 */
    readonly eq: Eq<T>;
    private _memo;
    private _refCount;
    private _subscription?;
    constructor(evaluate: (prev: Option<T>) => T, source$: Observable<T>, eq: Eq<T>);
    private readonly setMemo;
    /** @since 1.0.0 */
    readonly getValue: () => T;
    /** @since 1.0.0 */
    readonly setValue: (next: T) => void;
    /** @since 1.0.0 */
    readonly unsubscribe: () => void;
}
/** @since 3.0.0 */
declare const protect: <T extends ReadonlyAtom<unknown> | Atom<unknown>>(a: T) => T & Mim<TypeOf<T>>;
/** @since 3.0.0 */
type TypeOf<T> = T extends Atom<infer U1> ? U1 : T extends ReadonlyAtom<infer U2> ? U2 : T extends Mim<infer U3> ? U3 : never;

type Mim$1_Mim<T> = Mim<T>;
declare const Mim$1_Mim: typeof Mim;
declare const Mim$1_protect: typeof protect;
type Mim$1_TypeOf<T> = TypeOf<T>;
declare namespace Mim$1 {
  export {
    Mim$1_Mim as Mim,
    Mim$1_protect as protect,
    Mim$1_TypeOf as TypeOf,
  };
}

export { Mim$1 as M, TypeOf as T, Mim as a, protect as p };