import * as React from 'react';
import { Store } from 'redux';
import { Effect, FxState, FxSlice, FxActionCreators, FxActionsConfig } from 'fx-state';
import { Renderable, Omit } from './types';
declare type CallableEffectChildren<Data, Params extends any[]> = (state: FxState<Data, Params>, call: (...params: Params) => void) => Renderable;
export interface CallableEffectProps<Data, Params extends any[]> {
    effect: Effect<Data, Params> | FxActionsConfig<Data, Params>;
    children: CallableEffectChildren<Data, Params>;
    store?: Store<FxSlice>;
}
/**
 * CallableEffect is a React render-prop component that injects FxState for any side effect into its children.
 * It gives the consumer control over when the side-effect is executed.
 * This can be used for user-initiated side-effect calls, such as submitting a search or deleting a record.
 * Each instance of a CallableEffect will own its own unique FxState and FxActions.
 * On unmount, the component will destroy its FxState, cleaning up after itself.
 *
 * The following example initiates the given side-effect when the button is clicked.
 * While it is pending, it renders a loading indicator.
 * When it resolves, it renders the value that was passed to `resolve()`.
 * If the Promise is rejected, it renders the error that was passed to `reject()`.
 *
 * @example
 * ```
 * // typeof effect: (p1: number, p2: string) => Promise<string>
 *
 * <CallableEffect effect={effect} store={store}>
 *   {(state, call) =>
 *     <div>
 *       {state.error ? <span className="error">{state.error}</span>
 *          : state.data ? <span className="response">{state.data}</span>
            : state.status === 'active' && <span className="loading" />}
 *       <button onClick={() => call(123, 'abc')}>call effect</button>
 *     </div>}
 * </CallableEffect>
 * ```
 */
export declare class CallableEffect<Data, Params extends any[]> extends React.Component<CallableEffectProps<Data, Params>> {
    fxActions: FxActionCreators<Data, Params>;
    constructor(props: CallableEffectProps<Data, Params>);
    render(): JSX.Element;
}
/**
 * ContextCallableEffect is identical to CallableEffect, except that it uses StoreConsumer to pull the `store` prop off of Legacy React Context.
 */
export declare class ContextCallableEffect<Data, Params extends any[]> extends React.Component<Omit<CallableEffectProps<Data, Params>, 'store'>> {
    render(): JSX.Element;
}
export {};