import { Saga } from 'redux-saga';
import { PreloadedStoreState, NormalizedStoreOptions, StoreOptions, StoreMiddleware, StoreReducerFunction, StoreStateFromStateMap, StoreStateMap } from './types';
import { ReduxStoreContext } from './internal-types';
import { INTERNAL_SAGA_MANAGER_NAME, INTERNAL_STORE_UTILITY_DOMAIN } from './constants';
import { sagaManagerReducer, SagaCrashState } from './slices/saga-manager/saga-manager-slice';
import { storeUtilityReducer, StoreUtilityState } from './slices/store-utility/store-utility-slice';
import { SelectorFlushManager } from './utils/selector-core/throttled-selector-options';
import { SelectorTraceReporter } from './utils/selector-core/create-cached-selector';
type DefaultStoreReducersMap = {
    [INTERNAL_STORE_UTILITY_DOMAIN]: typeof storeUtilityReducer;
    [INTERNAL_SAGA_MANAGER_NAME]: typeof sagaManagerReducer;
};
type DefaultStoreStateMap = {
    [INTERNAL_STORE_UTILITY_DOMAIN]: StoreUtilityState;
    [INTERNAL_SAGA_MANAGER_NAME]: SagaCrashState;
};
export type StoreReducersInput<TStateMap extends StoreStateMap> = {
    [Domain in keyof TStateMap]: StoreReducerFunction<TStateMap[Domain]>;
};
export type StoreReducersMap<TStateMap extends StoreStateMap, TReducers extends StoreReducersInput<TStateMap> = StoreReducersInput<TStateMap>> = DefaultStoreReducersMap & TReducers;
export type StoreBoundState<TStateMap extends StoreStateMap> = StoreStateFromStateMap<DefaultStoreStateMap & TStateMap>;
export type StoreMiddlewareInput = StoreMiddleware | StoreMiddleware[];
export declare abstract class StoreRuntime<TStateMap extends StoreStateMap = {}, TReducers extends StoreReducersInput<TStateMap> = StoreReducersInput<TStateMap>> {
    private reducers;
    private middlewares;
    private readonly sagaMiddleware;
    private tasksStarted;
    private storeContext;
    private selectorFlushManager;
    private disposeDevTools;
    private selectorTracingEnabled;
    private maxLoggedSelectorAccessedPathCount;
    protected readonly storeOptions: NormalizedStoreOptions;
    constructor(reducersMap?: TReducers & StoreReducersInput<TStateMap>, middleware?: StoreMiddlewareInput, options?: StoreOptions);
    private registerReducer;
    addMiddleware(middleware: StoreMiddlewareInput): void;
    private getMiddlewarePipeline;
    private runSagaSafely;
    private createExtendedDefaultState;
    private stopSagas;
    private getOrCreateSelectorFlushManager;
    private disposeSelectorFlushManager;
    getReducers(): StoreReducersMap<TStateMap, TReducers>;
    get state(): StoreBoundState<TStateMap>;
    get dispatch(): ReduxStoreContext['store']['dispatch'];
    /**
     * Return an existing store context that should prevent re-initialization.
     * Defaults to the instance-level context (guards against double init());
     * framework-specific subclasses can override to consult external contexts.
     */
    protected getExistingStoreContext(): ReduxStoreContext | undefined;
    protected initStoreContext(initialState?: PreloadedStoreState): ReduxStoreContext | undefined;
    protected getSelectorFlushManager(): SelectorFlushManager;
    protected getSelectorTraceReporter<STATE, R, ARGS extends unknown[] = []>(): SelectorTraceReporter<STATE, R, ARGS>;
    private reportSelectorTrace;
    traceSelectors(): void;
    protected startSagaManager(storeContext: ReduxStoreContext): void;
    initDevTool(): () => void;
    dispose(): void;
    runSaga<TSaga extends Saga>(saga: TSaga): () => void;
}
export {};
//# sourceMappingURL=store-runtime.d.ts.map