/// <reference types="react" />
import { Reducer, Action, AnyAction, MiddlewareAPI, StoreEnhancer, Store } from 'redux';
interface Dispatch<A extends Action = AnyAction> {
    <T extends A>(action: T): Promise<any> | T;
}
interface ActionFunc {
    (api: MiddlewareAPI<any>): void;
}
interface ReducerEnhancer {
    (reducer: Reducer<any>): void;
}
export declare type ReducersMapObject<S = any, A extends Action = AnyAction> = {
    [K in keyof S]: Reducer<S[K], A>;
};
interface Hooks {
    onError?: (e: Error, dispatch: Dispatch<any>) => void;
    onAction?: ActionFunc | ActionFunc[];
    onStateChange?: () => void;
    onReducer?: ReducerEnhancer;
    onEffect?: () => void;
    onHmr?: () => void;
    extraReducers?: ReducersMapObject;
    extraEnhancers?: StoreEnhancer<any>[];
}
interface EffectsCommandMap {
    put: <A extends AnyAction>(action: A) => any;
    call: Function;
    select: Function;
    take: Function;
    cancel: Function;
    [key: string]: any;
}
declare type Effect = (action: AnyAction, effects: EffectsCommandMap) => void;
declare type EffectType = 'takeEvery' | 'takeLatest' | 'watcher' | 'throttle';
declare type EffectWithType = [Effect, {
    type: EffectType;
}];
declare type Subscription = (api: SubscriptionAPI, done: Function) => void;
declare type ReducersMapObjectWithEnhancer = [ReducersMapObject, ReducerEnhancer];
interface EffectsMapObject {
    [key: string]: Effect | EffectWithType;
}
interface SubscriptionAPI {
    history: any;
    dispatch: Dispatch<any>;
}
interface SubscriptionsMapObject {
    [key: string]: Subscription;
}
export interface Model {
    namespace: string;
    state?: any;
    reducers?: ReducersMapObject | ReducersMapObjectWithEnhancer;
    effects?: EffectsMapObject;
    subscriptions?: SubscriptionsMapObject;
}
interface RouterAPI {
    history: any;
    app: DvaInstance;
}
interface Router {
    (api?: RouterAPI): JSX.Element | Record<string, any>;
}
declare type HandleActions = (handles: any, defaultState: Pick<Model, 'state'>) => (state: any, action: AnyAction) => (prev: any, curr: any) => void;
interface Plugin {
    _handleActions: HandleActions;
    hooks: Hooks & {
        _handleActions: HandleActions;
    };
    use: (plugin: Hooks) => void;
    apply: (key: string, defaultHandler: Function) => (...args: any[]) => void;
    get: (key: keyof Hooks | '_handleActions') => any;
}
export interface DvaInstance {
    _models: Array<Model>;
    _store: Store;
    _plugin: Plugin;
    use: (hooks: Hooks) => void;
    model: (model: Model) => void;
    unmodel: (namespace: string) => void;
    router: (router: Router) => void;
    start: (selector?: HTMLElement | JSX.Element) => any;
    [key: string]: any;
}
export {};