type Dict<T> = Record<string, T>;

type Mutation<TState = unknown> = (
    payload: unknown,
    action: Record<string, unknown>
) => (state: TState) => TState;

type ActionGenerator = { type: string } & ((...args: any[]) => {
    type: string;
    payload?: unknown;
});

declare module 'updux' {
    /**
     * Configuration object typically passed to the constructor of the class Updux.
     */
    export interface UpduxConfig<TState = unknown> {
        /**
         * Local initial state.
         * @default {}
         */
        initial?: TState;

        /**
         * Subduxes to be merged to this dux.
         */
        subduxes?: Dict<Updux | UpduxConfig>;

        /**
         * Local actions.
         */
        actions?: Record<string, any>;

        /**
         * Local selectors.
         */
        selectors?: Record<string, Function>;

        /**
         * Local mutations
         */
        mutations?: Record<string, Function>;

        /**
         *  Selectors to apply to the mapped subduxes. Only
         *  applicable if the dux is a mapping dux.
         */
        mappedSelectors?: Record<string, Function>;

        /**
         * Local effects.
         */
        effects?: Record<string, Function>;

        /**
         * Local reactions.
         */
        reactions?: Record<string, Function>;
        /**
         * If true, enables mapped reactions. Additionally, it can be
         * a reaction function, which will treated as a regular
         * reaction for the mapped dux.
         */
        mappedReaction?: Function | boolean;
    }

    export class Updux<TState = unknown> {
        constructor(config: Partial<UpduxConfig<TState>>);

        get initial(): TState;
        get selectors(): unknown;

        /**
         * Sets the local mutation for the given action.
         *
         * The action can be specified via its type
         * or its generator.
         *
         * Returns the same mutation function.
         */
        setMutation<TMutation extends Mutation>(
            actionType: string,
            mutation: TMutation
        ): TMutation;
        setMutation<TMutation extends Mutation>(
            action: ActionGenerator,
            mutation: TMutation
        ): TMutation;

        /**
         * Registers the action for the dux.
         * If no payload function is provided, whatever is
         * given as an argument to the action generator will
         * be set as-is in the action's payload.
         */
        setAction(actionType: string, payloadFunc?: Function);
    }
}