import { Unsubscribe } from "redux";
/**
 * The only thing all action types have in common is a string
 * property called type, which must be unique across all actions
 * handled by the same reducer.
 *
 * We adopt the additional (popular) pattern of collecting any
 * further data into a single payload property. This makes the
 * very common case of a single value very succinct.
 */
export interface Action<T extends string, P> {
    readonly type: T;
    readonly payload: P;
}
/**
 * Common features of an ActionCreator and a CollectionDefinition.
 */
export interface ActionDefinition<S, T extends string, P> {
    readonly type: T;
    reduce(state: S, payload: P): S;
}
export declare function definition<S, T extends string, P, F>(type: T, reduce: (state: S, payload: P) => S, func: F): F & ActionDefinition<S, T, P>;
/**
 * An ActionCreator is a function that creates actions and can
 * also be registered with a reducer.
 */
export interface ActionCreator<S, T extends string, P> extends ActionDefinition<S, T, P> {
    (payload: P): Action<T, P>;
}
/**
 * Defines an action, for later inclusion in a reducer.
 */
export declare function action<S, T extends string, P>(type: T, reduce: (state: S, payload: P) => S): ActionCreator<S, T, P>;
/**
 * Almost a minimal reducer, except it also knows a good
 * initial state, known as 'empty'.
 */
export interface Reducer<S, A> {
    /**
     * Reduce function
     */
    (state: S, action: A): S;
    /**
     * A suitable initial state
     */
    empty: S;
}
/**
 * A reducer is a function that takes a state object and an action
 * and returns a modified state object. Here it is also equipped
 * with a method called action which allows multiple reducer
 * functions to be declaratively merged together into a single
 * function, and a store method that wraps Redux's createStore
 * to make it perfectly type-safe.
 *
 * Note that reducers are immutable - given a reducer x, calling
 * x.action(...) returns a new reducer combination rather than
 * modifying x.
 */
export interface ReducerBuilder<S, A> extends Reducer<S, A> {
    /**
     * Reduce function
     */
    (state: S, action: A): S;
    /**
     * A suitable initial state
     */
    empty: S;
    /**
     * Dummy member for use with typeof (does not have
     * a useful runtime value.)
     */
    actionType: A;
    cursorType: Cursor<S, A>;
    /**
     * Returns an enhanced ReducerBuilder capable of reducing
     * some additional action type.
     */
    action<T extends string, P>(definition: ActionDefinition<S, T, P>): ReducerBuilder<S, A | Action<T, P>>;
    /**
     * Creates a Redux store with extra type-safety.
     */
    store(): Store<S, A>;
    mixin<S2, A2>(reducer2: Reducer<S2, A2>): ReducerBuilder<S & S2, A | A2>;
}
export declare function builder<S, A>(empty: S, reduce: (state: S, action: A) => S): ReducerBuilder<S, A>;
/**
 * Creates a starter object from which a ReducerBuilder can be formed by
 * calling the action method.
 */
export declare function reducer<S>(empty: S): ReducerBuilder<S, never>;
export interface Subscribable {
    subscribe(listener: () => void): Unsubscribe;
}
/**
 * Describes a minimal Redux-like store. Note that stores are not
 * immutable (that's their whole purpose) and therefore getState is
 * not pure (it may return a different value each time you call it).
 */
export interface Store<S, A> extends Subscribable {
    dispatch<A1 extends A>(action: A1): A1;
    getState(): S;
}
/**
 * A pure representation of the state of a store or part of a store.
 * A cursor's value property never changes. Instead, the dispatch
 * method returns a new cursor representing the new state.
 *
 * Note that, unlike a traditional non-Redux cursor, updating is
 * always performed by dispatching an action.
 */
export interface Cursor<S, A> {
    /**
     * The state at the time this cursor was created.
     */
    readonly state: S;
    /**
     * Sends an action into the store's reducer, resulting in the
     * store updating, and a new cursor is returned representing
     * the new state.
     */
    (action: A): Cursor<S, A>;
    /**
     * Piping operator - allows left-to-write composition to navigate
     * down through a tree of cursors. This variant is for simple
     * references or properties.
     */
    $<S2, A2>(ref: (outer: Cursor<S, A>) => Cursor<S2, A2>): Cursor<S2, A2>;
}
export declare function cursor<S, A>(state: S, dispatch: (action: A) => Cursor<S, A>): Cursor<S, A>;
/**
 * Takes a snapshot of a Redux-like store, making it into a pure cursor.
 */
export declare function snapshot<S, A>(store: Store<S, A>): Cursor<S, A>;
export interface ReferenceDefinition<T extends string, S, I, A> extends ActionDefinition<S, T, A> {
    (outer: Cursor<S, Action<T, A>>): Cursor<I, A>;
    update(action: A): Action<T, A>;
}
export interface ReducerProvider<S, A> {
    reduce: Reducer<S, A>;
}
export declare type ReducerOrProvider<S, A> = Reducer<S, A> | ReducerProvider<S, A>;
export declare function getReducer<S, A>(reducerOrProvider: ReducerOrProvider<S, A>): Reducer<S, A>;
export declare function reference<T extends string, S, I, A>(type: T, reducerOrProvider: ReducerOrProvider<I, A>, get: (state: S) => I, set?: (state: S, item: I) => S): ReferenceDefinition<T, S, I, A>;
export interface At<K, A> {
    key: K;
    action: A;
}
export declare function collection<C, K, I, A>(reducerOrProvider: ReducerOrProvider<I, A>, get: (collection: C, key: K) => I | undefined, set: (collection: C, key: K, item: I) => C): ((key: K) => (outer: Cursor<C, Action<"AT", At<K, A>>>) => Cursor<I, A>) & {
    update: (key: K, action: A) => Action<"AT", At<K, A>>;
} & ActionDefinition<C, "AT", At<K, A>>;
export declare function array<I, A>(itemReducer: ReducerOrProvider<I, A>): ((key: number) => (outer: Cursor<I[], Action<"AT", At<number, A>>>) => Cursor<I, A>) & {
    update: (key: number, action: A) => Action<"AT", At<number, A>>;
} & ActionDefinition<I[], "AT", At<number, A>>;
export declare function objectByString<I, A>(itemReducer: ReducerOrProvider<I, A>): ((key: string) => (outer: Cursor<{
    [key: string]: I;
}, Action<"AT", At<string, A>>>) => Cursor<I, A>) & {
    update: (key: string, action: A) => Action<"AT", At<string, A>>;
} & ActionDefinition<{
    [key: string]: I;
}, "AT", At<string, A>>;
export declare function objectByNumber<I, A>(itemReducer: ReducerOrProvider<I, A>): ((key: number) => (outer: Cursor<{
    [key: number]: I;
}, Action<"AT", At<number, A>>>) => Cursor<I, A>) & {
    update: (key: number, action: A) => Action<"AT", At<number, A>>;
} & ActionDefinition<{
    [key: number]: I;
}, "AT", At<number, A>>;
export declare function removeFromObjectByString<I>(): ActionCreator<{
    [key: string]: I;
}, "REMOVE", string>;
export declare function removeFromObjectByNumber<I>(): ActionCreator<{
    [key: number]: I;
}, "REMOVE", number>;
export declare type Replace<V> = Action<"REPLACE", V>;
/**
 * Defines the reducer for a value that can only be assigned a whole new value.
 * It only supports the action "REPLACE" whose payload is the replacement value.
 */
export declare function primitive<V>(): ReducerBuilder<V, Action<"REPLACE", V>>;
/**
 * Action that replaces a whole value, supported by primitives
 */
export declare function replace<T>(value: T): Replace<T>;
/**
 * Property is just a type alias for a cursor to a primitive
 */
export declare type Property<V> = Cursor<V, Replace<V>>;
/**
 * Defines a property, which is a simple value that can be
 * replaced with a new value. It uses the primitive reducer.
 */
export declare function property<T extends string, S, V>(type: T, fetch: (state: S) => V, reduce?: (state: S, payload: V) => S): ReferenceDefinition<T, S, V, Replace<V>>;
/**
 * Basic substitute for Object.assign
 */
export declare function assign<T, S1, S2>(target: T, source1: S1, source2: S2): T & S1 & S2;
export declare function assign<T, S1>(target: T, source1: S1): T & S1;
/**
 * Pretty good subsitute for object spread syntax. Instead of:
 *
 *    { ...book, title }
 *
 * say:
 *
 *    amend(book, { title })
 */
export declare function amend<O1, O2>(o1: O1, o2: O2): {} & O1 & O2;