import { Atom, AtomSource, ObservableSeed, Observer, Property, Scope, Subscribe, TypeBitfield, Desc, Unsub, AtomSeed } from "./abstractions";
import { ObservableBase, ObservableSeedImpl } from "./observable";
import * as L from "./lens";
import { StatefulProperty, PropertyBase } from "./property";
import { HKT } from "./hkt";
export declare class LensedAtom<R, V> extends PropertyBase<V, Atom<V>> implements Atom<V> {
    [HKT]: Atom<V>;
    observableType(): "Atom";
    _L: TypeBitfield;
    private _root;
    private _lens;
    constructor(desc: Desc, root: Atom<R>, view: L.Lens<R, V>);
    get(): V;
    set(newValue: V): void;
    modify(fn: (old: V) => V): void;
    onChange(onValue: Observer<V>, onEnd?: Observer<void>): import("./abstractions").Callback;
    getScope(): Scope;
    applyScope(scope: Scope): Atom<V>;
}
export declare class StatefulDependentAtom<V> extends StatefulProperty<V, Atom<V>> implements Atom<V> {
    [HKT]: Atom<V>;
    observableType(): "Atom";
    _L: TypeBitfield;
    constructor(seed: ObservableSeed<V, AtomSource<V> | Atom<V>, Atom<V>>, scope: Scope);
    set: (updatedValue: V) => void;
    modify(fn: (old: V) => V): void;
    applyScope(scope: Scope): Atom<V>;
}
/**
 *  Input source for a StatefulProperty. Returns initial value and supplies changes to observer.
 *  Must skip duplicates!
 **/
export declare class AtomSeedImpl<V> extends ObservableSeedImpl<V, AtomSource<V>, Atom<V>> {
    [HKT]: AtomSeed<V>;
    observableType(): "AtomSeed";
    _L: TypeBitfield;
    constructor(desc: Desc, get: () => V, subscribe: Subscribe<V>, set: (updatedValue: V) => void);
    applyScope(scope: Scope): Atom<V>;
}
/**
 *  Input source for a StatefulProperty. Returns initial value and supplies changes to observer.
 *  Must skip duplicates!
 **/
export declare class AtomSourceImpl<V> extends ObservableBase<V, Atom<V>> implements AtomSource<V> {
    [HKT]: AtomSource<V>;
    _L: TypeBitfield;
    observableType(): "AtomSource";
    private _started;
    private _subscribed;
    private _get;
    onChange_: Subscribe<V>;
    set: (updatedValue: V) => void;
    get(): V;
    constructor(desc: Desc, get: () => V, subscribe: Subscribe<V>, set: (updatedValue: V) => void);
    onChange(onValue: Observer<V>, onEnd?: Observer<void>): Unsub;
    subscribe(onValue: Observer<V>, onEnd?: Observer<void>): Unsub;
    applyScope(scope: Scope): Atom<V>;
}
export declare function atom<A>(initial: A): Atom<A>;
/**
 * Create a dependent atom that reflects the value of the given Property. The `onChange` function
 * is supposed to eventually cause the `input` property to be updated to the new value.
 *
 * This constructor provides a bridge between atom-based components and "unidirectional data flow"
 * style state management.
 *
 * Note: unlike an independent atom, the dependent atom is lazy. This means that it will keep its
 * value up-to-date only if there is a subscriber to it or the underlying property.
 *
 * @param input      Property to reflect
 * @param onChange   Function to be called when `atom.set` is called
 */
export declare function atom<A>(input: Property<A>, onChange: (updatedValue: A) => void): Atom<A>;