import { Observable } from 'rxjs';
import { Controller } from './controller';
import { Query, QueryOptions } from './query';
/**
 * A function to update a state.
 *
 * It is recommended to return a new state or the previous one.
 *
 * Actually, the function can change the state in place, but it is responsible
 * for a developer to provide `comparator` function to the store which handles
 * the changes.
 *
 * For making changes use a currying function to provide arguments:
 * ```ts
 * const addPizzaToCart = (name: string): StateMutation<Array<string>> =>
 *   (state) => ([...state, name]);
 * ```
 *
 * @param state a previous state
 * @returns a next state
 */
export type StateMutation<State> = (state: State) => State;
/**
 * A record of factories which create state mutations.
 */
export type StateUpdates<State> = Readonly<Record<string, (...args: any[]) => StateMutation<State>>>;
/**
 * Declare a record of factories for creating state mutations.
 */
export declare function declareStateUpdates<State>(): <Updates extends StateUpdates<State> = StateUpdates<State>>(updates: Updates) => Updates;
/**
 * Declare a record of factories for creating state mutations.
 */
export declare function declareStateUpdates<State, Updates extends StateUpdates<State> = StateUpdates<State>>(stateExample: State, updates: Updates): Updates;
/**
 * Returns a mutation which applies all provided mutations for a state.
 *
 * You can use this helper to apply multiple changes at the same time.
 */
export declare function pipeStateMutations<State>(mutations: ReadonlyArray<StateMutation<State>>): StateMutation<State>;
/**
 * Read-only interface of a store.
 */
export type StoreQuery<State> = Readonly<Query<State> & {
    /**
     * Returns a part of the state as `Observable`
     * The result observable produces distinct values by default.
     *
     * @example
     * ```ts
     * const state: StateReader<{form: {login: 'foo'}}> = // ...
     * const value$ = state.select((state) => state.form.login);
     * ```
     */
    select: <R, K = R>(selector: (state: State) => R, options?: QueryOptions<R, K>) => Observable<R>;
    /**
     * Returns a part of the state as `Query`.
     * The result query produces distinct values by default.
     *
     * @example
     * ```ts
     * const state: StateReader<{form: {login: 'foo'}}> = // ...
     * const query = state.query((state) => state.form.login);
     * ```
     * */
    query: <R, K = R>(selector: (state: State) => R, options?: QueryOptions<R, K>) => Query<R>;
    /**
     * Cast the store to a narrowed `Query` type.
     */
    asQuery: () => Query<State>;
}>;
/**
 * @internal
 * Updates the state by provided mutations
 * */
export type StoreUpdateFunction<State> = (mutation: StateMutation<State> | ReadonlyArray<StateMutation<State> | undefined | null | false>) => void;
/** Function which changes a state of the store */
export type StoreUpdate<Args extends unknown[]> = (...args: Args) => void;
/** Record of store update functions */
export type StoreUpdates<State, Updates extends StateUpdates<State>> = Readonly<{
    [K in keyof Updates]: StoreUpdate<Parameters<Updates[K]>>;
}>;
/**
 * Store of a state
 */
export type Store<State> = Controller<StoreQuery<State> & {
    id: number;
    name?: string;
    /** Sets a new state to the store */
    set: (state: State) => void;
    /** Updates the store by provided mutations */
    update: StoreUpdateFunction<State>;
}>;
/** Store of a state with updating functions */
export type StoreWithUpdates<State, Updates extends StateUpdates<State>> = Readonly<Store<State> & {
    updates: StoreUpdates<State, Updates>;
}>;
export type StoreOptions<State> = Readonly<{
    name?: string;
    /** A comparator for detecting changes between old and new states */
    comparator?: (prevState: State, nextState: State) => boolean;
    /** Callback is called when the store is destroyed */
    onDestroy?: () => void;
}>;
/** @internal */
export type InternalStoreOptions<State> = Readonly<StoreOptions<State> & {
    internal?: boolean;
}>;
/**
 * Creates the state store.
 *
 * @param initialState Initial state
 * @param options Parameters for the store
 */
export declare function createStore<State>(initialState: State, options?: StoreOptions<State>): Store<State>;
/** Creates StateUpdates for updating the store by provided state mutations */
export declare function createStoreUpdates<State, Updates extends StateUpdates<State>>(storeUpdate: Store<State>['update'], stateUpdates: Updates): StoreUpdates<State, Updates>;
/** Creates a proxy for the store with "updates" to change a state by provided mutations */
export declare function withStoreUpdates<State, Updates extends StateUpdates<State> = StateUpdates<State>>(store: Store<State>, updates: Updates): StoreWithUpdates<State, Updates>;