export declare type Params = any[];
export declare type SubFn<V, P extends Params> = (...params: P) => V;
export declare type Subscription<V, P extends Params> = (...params: P) => IRef<V>;
export interface IRef<V> {
    deref(): V;
}
export interface ISource<V> {
    subscribe(onChange: (value: V) => any): void;
    unsubscribe(onChange: (value: V) => any): void;
}
export declare function isSource(obj: any): obj is ISource<any>;
export interface ISubContext {
    onEnter(): void;
    onExit(): void;
    /**
     * Dispose any active subscriptions
     */
    dispose(): void;
    /**
     * Define a child relationship; `this` Context now
     * depends on `parent`. This generally is only interesting
     * if `parent` is an `ISource`
     */
    subscribeTo(parent: ISubContext): void;
    /**
     * If any, returns a reference to the IStore this
     * context is bound to
     */
    store(): IStore<any> | null;
    /**
     * @see IChangeBatcher
     */
    requestBatchedChanges(batcher: IChangeBatcher): void;
}
/**
 * IChangeBatchers can register with a parent [ISubContext]
 * to be notified when all change events have been delivered.
 * This is a useful optimization for a [ISubContext] with
 * multiple dependencies to only notify its dependencies
 * one time
 */
export interface IChangeBatcher {
    notifyChangesBatched(): void;
}
export interface IContextManager {
    peek(): ISubContext | null;
    push(context: ISubContext): void;
    pop(context: ISubContext): void;
}
export declare type StoreEvent<T> = (old: T, store: IStore<T>) => T;
export declare type StoreEventFn<T> = (old: T) => T;
export declare type StorePropsEventFn<T, P extends Params> = (old: T, ...props: P) => T;
export interface IDispatchFn<StoreState> {
    (event: StoreEvent<StoreState>): void;
}
export interface IStore<V> extends IRef<V> {
    /**
     * Dispatch a StoreEvent, created by one of the factories in the
     * `events` module.
     */
    dispatch: IDispatchFn<V>;
    /**
     * Dispatch a StoreEvent *synchronously*, created by one of the
     * factories in the `events` module.
     */
    dispatchSync: IDispatchFn<V>;
    getSnapshot(): V;
    loadSnapshot(snapshot: V): void;
}
export interface IStoreImpl<V> extends IStore<V> {
}
export declare type SimpleEffectHandler<P extends Params> = (...params: P) => any;
export declare type StateEffectHandler<State, P extends Params> = (store: IStore<State>, ...params: P) => any;
export declare type EffectHandler<State, P extends Params> = SimpleEffectHandler<P> | StateEffectHandler<State, P>;
export declare type EffectHandlerParams<T> = T extends StateEffectHandler<infer _, infer SP> ? SP : T extends SimpleEffectHandler<infer P> ? P : never;
export declare type EffectVector<P extends Params, T extends EffectHandler<any, P>> = [T, P];
export declare type _EffectVector<T extends EffectHandler<any, any>> = [T, EffectHandlerParams<T>];
export declare type StateEffectVector<State> = _EffectVector<EffectHandler<State, any[]>>;
/**
 * Public Effector interface
 */
export interface IFx<State> {
    /** Produce an effect */
    produce<P extends Params>(handler: SimpleEffectHandler<P>, ...params: P): void;
    produce<P extends Params>(handler: StateEffectHandler<State, P>, ...params: P): void;
    store(newState: State): void;
    dispatch(event: StoreEvent<State>): void;
    dispatchLater(event: StoreEvent<State>, timeoutMillis: number): void;
}
/** "Internal" interface for IFx implementations */
export interface IConfigurableFx<State> extends IFx<State> {
    state: State;
    effects: StateEffectVector<State>[];
    invokeQueued(store: IStore<State>): void;
    reset(): void;
}
export interface IEffectorFactory<State> {
    acquire(state: State): IConfigurableFx<State>;
    release(effector: IConfigurableFx<State>): void;
}