import { HKT } from "./hkt";
import { Pipeable } from "./pipeable";
import { GenericTransformOpScoped } from "./transform";
export declare type TypeBitfield = number;
export declare const T_SCOPED = 7;
export declare const T_SEED = 2;
export declare const T_SOURCE = 4;
export declare const T_PROPERTY = 16;
export declare const T_STREAM = 32;
export declare const T_ATOM = 80;
export declare const T_EVENT = 256;
export declare const T_SCOPE = 512;
export declare const T_VALUE = 4352;
export declare const T_END = 8448;
export declare function matchFlags(o: any, flags: TypeBitfield): boolean;
export declare function isProperty<V>(e: any): e is Property<V>;
export declare function isPropertySeed<V>(e: any): e is PropertySeed<V>;
export declare function isPropertySource<V>(e: any): e is PropertySource<V>;
export declare function isEventStream<V>(e: any): e is EventStream<V>;
export declare function isEventStreamSeed<V>(e: any): e is EventStreamSeed<V>;
export declare function isEventStreamSource<V>(e: any): e is EventStreamSeed<V>;
export declare function isAtom<V>(e: any): e is Atom<V>;
export declare function isAtomSeed<V>(e: any): e is AtomSeed<V>;
export declare function isAtomSource<V>(e: any): e is AtomSeed<V>;
export declare function isObservableSeed<V, C extends Observable<any>, O extends ScopedObservable<any>>(e: any): e is ObservableSeed<V, C, O>;
export declare type Callback = () => void;
export declare type Observer<V> = (value: V) => void;
export declare type Subscribe<V> = (onValue: Observer<V>, onEnd?: Observer<void>) => Unsub;
export declare type Unsub = Callback;
export declare class Description {
    desc: Desc;
    constructor(desc: Desc);
    toString(): string;
}
export declare type Desc = Description | DescWithContext | MethodDesc | string;
export declare type MethodDesc = [string, any[]];
export declare type DescWithContext = [any, string, any[]];
export declare function composeDesc(context: any, methodCall: MethodDesc): DescWithContext;
export declare abstract class Event<V> {
    _L: TypeBitfield;
}
export declare class Value<V> extends Event<V> {
    _L: TypeBitfield;
    value: V;
    constructor(value: V);
}
export declare class End extends Event<any> {
    _L: TypeBitfield;
}
export declare type EventLike<V> = Event<V>[] | Event<V> | V;
export declare function toEvent<V>(value: Event<V> | V): Event<V>;
export declare function isEvent<V>(value: any): value is Event<V>;
export declare function toEvents<V>(value: EventLike<V>): Event<V>[];
export declare function valueEvent<V>(value: V): Value<V>;
export declare function isValue<V>(event: Event<V>): event is Value<V>;
export declare function isEnd<V>(event: Event<V>): event is End;
export declare const endEvent: End;
export declare function valueObserver<V>(observer: Observer<V>): Observer<Event<V>>;
export interface ObservableIdentifiers {
    _L: TypeBitfield;
    desc: Description;
    toString(): string;
}
export interface ForEach<V> {
    forEach(observer: Observer<V>): Unsub;
    log(message?: string): Unsub;
}
export declare type Observable<V> = ObservableIdentifiers & ForEach<V> & {
    subscribe(onValue: Observer<V>, onEnd?: Observer<void>): Unsub;
};
export interface ObservableSeed<V, C extends Observable<unknown>, O extends ScopedObservable<unknown>> extends Pipeable, ObservableIdentifiers, ForEach<V> {
    observableType(): string;
    consume(): C;
    applyScope(scope: Scope): O;
}
export declare type ScopedObservable<V> = Observable<V> & {
    getScope(): Scope;
};
export interface PropertyMethods<V> {
    get(): V;
    onChange(onValue: Observer<V>, onEnd?: Observer<void> | undefined): Unsub;
}
export declare type PropertySource<V> = Observable<V> & PropertySeed<V> & PropertyMethods<V> & HKT<PropertySource<V>> & {
    observableType(): "PropertySource" | "Property" | "AtomSource" | "Atom";
};
export declare type Property<V> = ScopedObservable<V> & PropertySource<V> & PropertyMethods<V> & HKT<Property<V>> & {
    observableType(): "Property" | "Atom";
};
export declare type PropertySeed<V> = ObservableSeed<V, PropertySource<V>, Property<V>> & HKT<PropertySeed<V>> & {
    observableType(): "PropertySeed" | "PropertySource" | "Property" | "AtomSeed" | "AtomSource" | "Atom";
};
export declare type EventStreamSource<V> = Observable<V> & EventStreamSeed<V> & HKT<EventStreamSource<V>> & {
    observableType(): "EventStreamSource" | "EventStream" | "Bus";
};
export declare type EventStream<V> = ScopedObservable<V> & EventStreamSource<V> & HKT<EventStream<V>> & {
    observableType(): "EventStream" | "Bus";
};
export declare type EventStreamSeed<V> = ObservableSeed<V, EventStreamSource<V>, EventStream<V>> & HKT<EventStreamSeed<V>> & {
    observableType(): "EventStreamSeed" | "EventStreamSource" | "EventStream" | "Bus";
};
export declare type AtomSource<V> = PropertySource<V> & PropertySeed<V> & AtomSeed<V> & HKT<AtomSource<V>> & {
    observableType(): "AtomSource" | "Atom";
    set(updatedValue: V): void;
};
export declare type AtomSeed<V> = ObservableSeed<V, AtomSource<V>, Atom<V>> & HKT<AtomSeed<V>> & {
    observableType(): "AtomSeed" | "AtomSource" | "Atom";
};
export declare type Atom<V> = Property<V> & AtomSource<V> & HKT<Atom<V>> & {
    observableType(): "Atom";
    set(newValue: V): void;
    modify(fn: (old: V) => V): void;
};
export interface Bus<V> extends EventStream<V> {
    push(newValue: V): void;
    end(): void;
}
export declare type ScopeFn = (onIn: () => Unsub) => void;
export declare type Scope = GenericTransformOpScoped & {
    _L: typeof T_SCOPE;
    subscribe: ScopeFn;
};
export declare function isScope(x: any): x is Scope;
export declare type Function0<R> = () => R;
export declare type Function1<T1, R> = (t1: T1) => R;
export declare type Function2<T1, T2, R> = (t1: T1, t2: T2) => R;
export declare type Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
export declare type Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
export declare type Function5<T1, T2, T3, T4, T5, R> = (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R;
export declare type Function6<T1, T2, T3, T4, T5, T6, R> = (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6) => R;