/// <reference types="react" />
/// <reference types="node" />
import * as React from "react";
import * as Redux from "redux";
import * as Router from "./router";
import EditableText from "./EditableText";
export * from "type-zoo";
export * from "./types";
import List from "./list";
import moize from "moize";
export declare type JSXElement = React.ReactElement<any>;
export { React, EditableText, JSX, List, moize };
export declare type AnyAction = Redux.Action;
export declare type Dispatch = <E>(action: Redux.Action, eventToStop?: React.SyntheticEvent<E> | Event) => void;
export declare type Dispatcher = {
    dispatch: Dispatch;
};
export declare const lift: <E>(dispatch: Dispatch, props: {}) => (action: Redux.Action, e?: Event | React.SyntheticEvent<E> | undefined) => void;
export declare class Component<P> extends React.PureComponent<P & Dispatcher> {
    constructor(props: P & Dispatcher);
    dispatch<A extends Redux.Action, E>(action: A, eventToStop?: React.SyntheticEvent<E> | Event): void;
}
export declare enum ActionType {
    Init = "ReactiveElm/Init",
}
export declare type InitType = ActionType;
export declare const InitType: ActionType;
export interface Init {
    type: "ReactiveElm/Init";
}
export declare const init: {
    type: string;
};
export declare type Goto<Route> = Router.Action<Route>;
export declare type GotoType = Router.ActionType;
export declare const GotoType: Router.ActionType;
export declare const goto: <Route>(route: Route, opts?: Router.GotoOpts) => Router.Goto<Route>;
export declare type Update<S, A extends AnyAction> = (state: S, action: A, dispatch: Dispatch) => S;
export declare type WrappedUpdate<S, A extends AnyAction> = (state: S, action: A) => S;
export interface Opts {
    baseUri?: string;
    rootHTMLElement?: Element | null;
    remoteDevTools?: {
        name: string;
        hostname: string;
        port: number;
    };
    onLoad: () => any;
}
export declare const load: <State extends Router.State<Route>, Action extends Redux.Action, Route>(initialState: State, reactsTo: (action: Redux.Action) => action is Action, update: Update<State, Action>, RootJSXElement: (new (state: State & Dispatcher) => Component<State>) | ((state: State) => React.ReactElement<any>), routeToUri: Router.RouteToUri<Route>, uriToRoute: Router.UriToRoute<Route>, module: NodeModule, opts?: Opts) => void;
export interface HotModule extends NodeModule {
    hot: {
        accept: (file?: string, cb?: () => void) => void;
        dispose: (callback: () => void) => void;
    } | null;
}
export declare const withDispatch: <S, A extends Redux.Action>(f: Update<S, A>) => WrappedUpdate<S, A>;
export declare const exists: (it: any) => boolean;
export declare function log<T>(value: T, ...others: any[]): T;
export declare type Mutable<T extends {
    [x: string]: any;
}, K extends string> = {
    [P in K]: T[P];
};