import {Middleware} from 'redux';


/** Create a redux-off-main-thread middleware instance. This should be run on the worker thread. */
export declare function createReduxOMTMiddleware(): Middleware;


/**
 * Resolves with the initial state when the worker receives an initial state message.
 * Rejects when called outside a worker thread.
 */
export declare function onReduxWorkerThreadInitialStateReceived(): Promise<any>;


/**
 * Resolves when the worker receives a ready event, indicating that the main thread has finished setting up
 * event listeners. Should be instant unless you've created some weird environment e.g. during CI.
 * Rejects when called outside a worker thread.
 */
export declare function onReduxWorkerThreadReady(): Promise<void>;


/**
 * Used to provide the initial state to a main thread worker initialised via {@link resolveWrappedStore}. This function
 * should be called immediately on the worker entrypoint.
 * @return A void promise that resolves once the initial state request has been fulfilled.
 */
export declare function provideReduxOMTInitialState<S = any>(state: S): Promise<void>;

import type {Action, AnyAction, Store} from 'redux';
import type {EnhancerOptions} from 'redux-devtools-extension';


export declare type WorkerPartial = Pick<Worker, 'addEventListener' | 'postMessage' | 'removeEventListener'>;


/** A Redux store wrapped to run off the main thread */
export type WrappedStore<S, A extends Action = AnyAction> = Store<S, A> & {
  
  /**
   * Actions no longer mutate the state synchronously, therefore the store no longer behaves exactly as a regular
   * Redux store:
   * <code>
   *   const oldState = store.getState();
   *   store.dispatch({type: 'some-valid-action-that-should-mutate-the-state''});
   *   // True on an off-main-thread store, false on a regular store
   *   console.log(oldState === store.getState());
   * </code>
   * This method can be used to react to when the store off the main thread
   */
  onChange(listener: (action: A, newState: S, oldState: S) => void): () => void;
}


/** {@link createWrappedStore} initialisation config */
export interface CreateWrappedStoreInit<S> {
    /**
     * Options for enabling devtools support. Can be either an {@link EnhancerOptions} object or true,
     * which is equivalent to passing {}
     * @default false
     */
    devtoolsInit?: boolean | EnhancerOptions;
    /** Initial store state */
    initialState: S;
    /**
     * Having this as false requires the main thread and worker thread to set the same initial state from an object
     * somewhere in your codebase (and bundled by your build system) and is suitable for the
     * {@link https://github.com/Alorel/redux-off-main-thread/tree/master#basic-usage Basic usage} use case. You may
     * instead opt to only set this to true and send the initial state as a message to the worker; this is outlined in the
     * {@link https://github.com/Alorel/redux-off-main-thread/tree/master#sending-default-state-from-the-main-thread Sending default state from the main thread}
     * example.
     * @default false
     */
    syncInitialState?: boolean;
    /** The worker instance Redux is running on */
    worker: WorkerPartial;
}


/**
 * Create a wrapped store with the same API as a regular Redux store bar several differences:
 * <ul>
 *   <li>It does not have any reducers, replaceReducer throws an error</li>
 *   <li>It does not have a Symbol.observable</li>
 *   <li>Actions do not synchronously update the state anymore, therefore the subscribe() function may not behave as expected</li>
 *   <li>It has an extra onChange() method</li>
 * </ul>
 * @param init
 */
export declare function createWrappedStore<S, A extends Action = AnyAction>(init: CreateWrappedStoreInit<S>): WrappedStore<S, A>;


/** Same as a regular {@link CreateWrappedStoreInit}, but with initialState & syncInitialState omitted */
export declare type ResolveWrappedStoreInit<S> = Omit<CreateWrappedStoreInit<S>, 'initialState' | 'syncInitialState'>;


/**
 * Similar to {@link createWrappedStore}, but the store on the worker is used to provide the initial state via
 * {@link provideReduxOMTInitialState}.
 * @return A promise that resolves with a {@link WrappedStore} when the worker store is initialised.
 */
export declare function resolveWrappedStore<S, A extends Action>(init: ResolveWrappedStoreInit<S>): Promise<WrappedStore<S, A>>;