import { Observable } from 'kefir';
import { Saga } from 'redux-saga';
import { PreloadedStoreState, NormalizedStoreOptions, StoreOptions, StoreMiddleware, StoreReducerFunction, StoreStateFromStateMap, StoreStateMap, SelectorTraceSummary, StoreTraceStreams } 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 { SelectorTraceReporter } from './utils/types';
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 readonly reduxLoggerMiddleware;
    private tasksStarted;
    private storeContext;
    private selectorCadenceSource;
    private cadencedStoreStateStream;
    private disposeDevTools;
    private selectorTracingEnabled;
    private readonly selectorTraceReporter;
    private selectorTraceSummaryCollector;
    private selectorTraceSummaryInterval;
    private selectorTracingOptions;
    private readonly legacySelectorTracingActivationAllowed;
    protected readonly storeOptions: NormalizedStoreOptions;
    private readonly traceEmitters;
    readonly traceStreams: StoreTraceStreams;
    private loggerDisposer;
    private loggerSubscriptions;
    constructor(reducersMap?: TReducers & StoreReducersInput<TStateMap>, middleware?: StoreMiddlewareInput, options?: StoreOptions);
    private registerReducer;
    addMiddleware(middleware: StoreMiddlewareInput): void;
    private getMiddlewarePipeline;
    private runSagaSafely;
    private createExtendedDefaultState;
    private stopSagas;
    private getOrCreateSelectorCadenceSource;
    private disposeSelectorCadenceSource;
    private disposeCadencedStoreStateStream;
    private publishTrace;
    reportRuntimeError(error: unknown, source?: string, message?: string, payload?: unknown): void;
    private attachLogger;
    private disposeLogger;
    getStoreStateStream(): Observable<StoreBoundState<TStateMap>, any>;
    getStoreStateSnapshot(): StoreBoundState<TStateMap>;
    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;
    init(initialState?: PreloadedStoreState): () => void;
    getSelectorTraceReporter<STATE, R, ARGS extends unknown[] = []>(): SelectorTraceReporter<STATE, R, ARGS> | undefined;
    shouldTraceSelectorCache(): boolean;
    getSelectorTraceSummary(): SelectorTraceSummary;
    private registerSelectorTracingBridge;
    private reportSelectorTrace;
    traceSelectors(): void;
    private startSelectorTraceSummaryInterval;
    private isPeriodSummaryEligible;
    private disposeSelectorTraceSummaryInterval;
    protected startSagaManager(storeContext: ReduxStoreContext): void;
    initDevTool(): () => void;
    dispose(): void;
    runSaga<TSaga extends Saga>(saga: TSaga): () => void;
}
export {};
//# sourceMappingURL=store-runtime.d.ts.map