import * as react0 from "react";
import { ReactElement } from "react";
import { Draft, Patch, PatchListener } from "immer";

//#region src/Store.d.ts
type TPullstateUpdateListener = () => void;
interface IStoreInternalOptions<S extends object> {
  ssr: boolean;
  reactionCreators?: TReactionCreator<S>[];
}
type TUpdateFunction<S> = (draft: Draft<S>, original: S) => void;
type TReactionFunction<S extends any, T> = (watched: T, draft: Draft<S>, original: S, previousWatched: T) => void;
type TRunReactionFunction = (forceRun?: boolean) => string[];
type TReactionCreator<S extends object> = (store: Store<S>) => TRunReactionFunction;
interface ICreateReactionOptions {
  runNow?: boolean;
  runNowWithSideEffects?: boolean;
}
type TStoreActionUpdate<S extends object> = (updater: TUpdateFunction<S> | TUpdateFunction<S>[], patchesCallback?: (patches: Patch[], inversePatches: Patch[]) => void) => void;
type TStoreAction<S extends object> = (update: TStoreActionUpdate<S>) => void;
declare class Store<S extends object = object> {
  private updateListeners;
  private currentState;
  private readonly initialState;
  private readonly createInitialState;
  private internalOrdId;
  private batchState;
  private ssr;
  private reactions;
  private clientSubscriptions;
  private reactionCreators;
  private optimizedUpdateListeners;
  private optimizedUpdateListenerPaths;
  private optimizedListenerPropertyMap;
  _optListenerCount: number;
  _patchListeners: PatchListener[];
  constructor(initialState: S | (() => S));
  _setInternalOptions({
    ssr,
    reactionCreators
  }: IStoreInternalOptions<S>): void;
  _getReactionCreators(): TReactionCreator<S>[];
  _instantiateReactions(): void;
  _getInitialState(): S;
  _updateStateWithoutReaction(nextState: S): void;
  _updateState(nextState: S, updateKeyedPaths?: string[]): void;
  _addUpdateListener(listener: TPullstateUpdateListener): void;
  _removeUpdateListener(listener: TPullstateUpdateListener): void;
  _removeUpdateListenerOpt(ordKey: string): void;
  listenToPatches(patchListener: PatchListener): () => void;
  subscribe<T>(watch: (state: S) => T, listener: (watched: T, allState: S, previousWatched: T) => void): () => void;
  createReaction<T>(watch: (state: S) => T, reaction: TReactionFunction<S, T>, {
    runNow,
    runNowWithSideEffects
  }?: ICreateReactionOptions): () => void;
  getRawState(): S;
  useState(): S;
  useState<SS = any>(getSubState: (state: S) => SS, deps?: ReadonlyArray<any>): SS;
  useLocalCopyInitial(deps?: ReadonlyArray<any>): Store<S>;
  useLocalCopySnapshot(deps?: ReadonlyArray<any>): Store<S>;
  flushBatch(ignoreError?: boolean): void;
  update(updater: TUpdateFunction<S> | TUpdateFunction<S>[], patchesCallback?: (patches: Patch[], inversePatches: Patch[]) => void): void;
  replace(newState: S): void;
  replaceFromCurrent(replacer: (state: S) => S): void;
  applyPatches(patches: Patch[]): void;
}
declare function update<S extends object = object>(store: Store<S>, updater: TUpdateFunction<S> | TUpdateFunction<S>[], patchesCallback?: (patches: Patch[], inversePatches: Patch[]) => void): void;
//#endregion
//#region src/useStoreState.d.ts
declare function useStoreState<S extends object = any>(store: Store<S>): S;
declare function useStoreState<S extends object = any, SS = any>(store: Store<S>, getSubState: (state: S) => SS, deps?: ReadonlyArray<any>): SS;
//#endregion
//#region src/InjectStoreState.d.ts
interface IPropsInjectStoreState<S extends object = any, SS extends any = any> {
  store: Store<S>;
  on?: (state: S) => SS;
  children: (output: SS) => ReactElement;
}
declare function InjectStoreState<S extends object = any, SS = any>({
  store,
  on,
  children
}: IPropsInjectStoreState<S, SS>): ReactElement;
//#endregion
//#region src/async-types.d.ts
type TPullstateAsyncUpdateListener = () => void;
type TPullstateAsyncWatchResponse<R = any, T extends string = string, N = any> = [boolean, boolean, TAsyncActionResult<R, T, N>, boolean, number];
type TPullstateAsyncBeckonResponse<R = any, T extends string = string, N = any> = [boolean, TAsyncActionResult<R, T, N>, boolean];
type TPullstateAsyncRunResponse<R = any, T extends string = string, N = any> = Promise<TAsyncActionResult<R, T, N>>;
interface IPullstateAsyncResultState {
  [key: string]: TPullstateAsyncWatchResponse<any, string, any>;
}
interface IPullstateAsyncActionOrdState {
  [key: string]: number;
}
declare enum EAsyncEndTags {
  THREW_ERROR = "THREW_ERROR",
  RETURNED_ERROR = "RETURNED_ERROR",
  UNFINISHED = "UNFINISHED",
  DORMANT = "DORMANT",
}
interface IAsyncActionResultBase<T extends string> {
  message: string;
  tags: (EAsyncEndTags | T)[];
}
interface IAsyncActionResultPositive<R, T extends string> extends IAsyncActionResultBase<T> {
  error: false;
  payload: R;
  errorPayload: null;
}
interface IAsyncActionResultNegative<T extends string, N = unknown> extends IAsyncActionResultBase<T> {
  error: true;
  errorPayload: N;
  payload: null;
}
type TAsyncActionResult<R, T extends string, N> = IAsyncActionResultPositive<R, T> | IAsyncActionResultNegative<T, N>;
type TPullstateAsyncShortCircuitHook<A, R, T extends string, N, S extends IPullstateAllStores> = (inputs: {
  args: A;
  stores: S;
}) => TAsyncActionResult<R, T, N> | false;
type TPullstateAsyncCacheBreakHook<A, R, T extends string, N, S extends IPullstateAllStores> = (inputs: {
  args: A;
  result: TAsyncActionResult<R, T, N>;
  stores: S;
  timeCached: number;
}) => boolean;
declare enum EPostActionContext {
  WATCH_HIT_CACHE = "WATCH_HIT_CACHE",
  BECKON_HIT_CACHE = "BECKON_HIT_CACHE",
  RUN_HIT_CACHE = "RUN_HIT_CACHE",
  READ_HIT_CACHE = "READ_HIT_CACHE",
  READ_RUN = "READ_RUN",
  SHORT_CIRCUIT = "SHORT_CIRCUIT",
  DIRECT_RUN = "DIRECT_RUN",
  BECKON_RUN = "BECKON_RUN",
  CACHE_UPDATE = "CACHE_UPDATE",
}
type TPullstateAsyncPostActionHook<A, R, T extends string, N, S extends IPullstateAllStores> = (inputs: {
  args: A;
  result: TAsyncActionResult<R, T, N>;
  stores: S;
  context: EPostActionContext;
}) => void;
interface IAsyncActionReadOptions<A, R, T extends string, N, S extends IPullstateAllStores> {
  postActionEnabled?: boolean;
  cacheBreakEnabled?: boolean;
  key?: string;
  cacheBreak?: boolean | number | TPullstateAsyncCacheBreakHook<A, R, T, N, S>;
}
interface IAsyncActionBeckonOptions<A, R, T extends string, N, S extends IPullstateAllStores> extends IAsyncActionReadOptions<A, R, T, N, S> {
  ssr?: boolean;
  holdPrevious?: boolean;
  dormant?: boolean;
}
interface IAsyncActionWatchOptions<A, R, T extends string, N, S extends IPullstateAllStores> extends IAsyncActionBeckonOptions<A, R, T, N, S> {
  initiate?: boolean;
}
interface IAsyncActionUseOptions<A, R, T extends string, N, S extends IPullstateAllStores> extends IAsyncActionWatchOptions<A, R, T, N, S> {
  onSuccess?: (result: R, args: A) => void;
}
interface IAsyncActionUseDeferOptions<A, R, T extends string, N, S extends IPullstateAllStores> extends Omit<IAsyncActionReadOptions<A, R, T, N, S>, "key"> {
  key?: string;
  holdPrevious?: boolean;
  onSuccess?: (result: R, args: A) => void;
  clearOnSuccess?: boolean;
}
interface IAsyncActionRunOptions<A, R, T extends string, N, S extends IPullstateAllStores> {
  treatAsUpdate?: boolean;
  ignoreShortCircuit?: boolean;
  respectCache?: boolean;
  key?: string;
  cacheBreak?: boolean | number | TPullstateAsyncCacheBreakHook<A, R, T, N, S>;
  _asyncCache?: IPullstateAsyncCache;
  _stores?: S;
  _customContext?: any;
}
interface IAsyncActionGetCachedOptions<A, R, T extends string, N, S extends IPullstateAllStores> {
  checkCacheBreak?: boolean;
  cacheBreak?: boolean | number | TPullstateAsyncCacheBreakHook<A, R, T, N, S>;
  key?: string;
}
interface IGetCachedResponse<R, T extends string, N = any> {
  started: boolean;
  finished: boolean;
  result: TAsyncActionResult<R, T, N>;
  updating: boolean;
  existed: boolean;
  cacheBreakable: boolean;
  timeCached: number;
}
interface IAsyncClearCacheOptions {
  notify?: boolean;
}
interface IAsyncActionSetOrClearCachedValueOptions extends IAsyncClearCacheOptions {
  key?: string;
}
interface IAsyncActionUpdateCachedOptions extends IAsyncActionSetOrClearCachedValueOptions {
  resetTimeCached?: boolean;
  runPostActionHook?: boolean;
}
type TAsyncActionUse<A, R, T extends string, N, S extends IPullstateAllStores> = (args?: A, options?: IAsyncActionUseOptions<A, R, T, N, S>) => TUseResponse<A, R, T, N, S>;
type TAsyncActionUseDefer<A, R, T extends string, N, S extends IPullstateAllStores> = (options?: IAsyncActionUseDeferOptions<A, R, T, N, S>) => TUseDeferResponse<A, R, T, N, S>;
type TAsyncActionBeckon<A, R, T extends string, N, S extends IPullstateAllStores> = (args?: A, options?: IAsyncActionBeckonOptions<A, R, T, N, S>) => TPullstateAsyncBeckonResponse<R, T, N>;
type TAsyncActionWatch<A, R, T extends string, N, S extends IPullstateAllStores> = (args?: A, options?: IAsyncActionWatchOptions<A, R, T, N, S>) => TPullstateAsyncWatchResponse<R, T, N>;
type TAsyncActionRun<A, R, T extends string, N, S extends IPullstateAllStores> = (args?: A, options?: IAsyncActionRunOptions<A, R, T, N, S>) => TPullstateAsyncRunResponse<R, T, N>;
type TAsyncActionClearCache<A> = (args?: A, options?: IAsyncActionSetOrClearCachedValueOptions) => void;
type TAsyncActionClearAllCache = (options?: IAsyncClearCacheOptions) => void;
type TAsyncActionClearAllUnwatchedCache = (options?: IAsyncClearCacheOptions) => void;
type TAsyncActionGetCached<A, R, T extends string, N, S extends IPullstateAllStores> = (args?: A, options?: IAsyncActionGetCachedOptions<A, R, T, N, S>) => IGetCachedResponse<R, T, N>;
type TAsyncActionSetCached<A, R, T extends string, N> = (args: A, result: TAsyncActionResult<R, T, N>, options?: IAsyncActionSetOrClearCachedValueOptions) => void;
type TAsyncActionSetCachedPayload<A, R> = (args: A, payload: R, options?: IAsyncActionSetOrClearCachedValueOptions) => void;
type TAsyncActionUpdateCached<A, R> = (args: A, updater: TUpdateFunction<R>, options?: IAsyncActionUpdateCachedOptions) => void;
type TAsyncActionRead<A, R, T extends string, N, S extends IPullstateAllStores> = (args?: A, options?: IAsyncActionReadOptions<A, R, T, N, S>) => R;
type TAsyncActionDelayedRun<A, R, T extends string, N, S extends IPullstateAllStores> = (args: A, options: IAsyncActionRunOptions<A, R, T, N, S> & {
  delay: number;
  clearOldRun?: boolean;
  immediateIfCached?: boolean;
}) => () => void;
interface IOCreateAsyncActionOutput<A = any, R = any, T extends string = string, N = any, S extends IPullstateAllStores = IPullstateAllStores> {
  use: TAsyncActionUse<A, R, T, N, S>;
  useDefer: TAsyncActionUseDefer<A, R, T, N, S>;
  read: TAsyncActionRead<A, R, T, N, S>;
  useBeckon: TAsyncActionBeckon<A, R, T, N, S>;
  useWatch: TAsyncActionWatch<A, R, T, N, S>;
  run: TAsyncActionRun<A, R, T, N, S>;
  delayedRun: TAsyncActionDelayedRun<A, R, T, N, S>;
  getCached: TAsyncActionGetCached<A, R, T, N, S>;
  setCached: TAsyncActionSetCached<A, R, T, N>;
  setCachedPayload: TAsyncActionSetCachedPayload<A, R>;
  updateCached: TAsyncActionUpdateCached<A, R>;
  clearCache: TAsyncActionClearCache<A>;
  clearAllCache: TAsyncActionClearAllCache;
  clearAllUnwatchedCache: TAsyncActionClearAllUnwatchedCache;
}
interface IPullstateAsyncCache {
  results: IPullstateAsyncResultState;
  listeners: {
    [key: string]: {
      [watchId: string]: TPullstateAsyncUpdateListener;
    };
  };
  actions: {
    [key: string]: () => Promise<TAsyncActionResult<any, string, any>>;
  };
  actionOrd: IPullstateAsyncActionOrdState;
}
type TPullstateAsyncAction<A, R, T extends string, N, S extends IPullstateAllStores> = (args: A, stores: S, customContext: any) => Promise<TAsyncActionResult<R, T, N>>;
interface ICreateAsyncActionOptions<A, R, T extends string, N, S extends IPullstateAllStores> {
  forceContext?: boolean;
  shortCircuitHook?: TPullstateAsyncShortCircuitHook<A, R, T, N, S>;
  cacheBreakHook?: TPullstateAsyncCacheBreakHook<A, R, T, N, S>;
  postActionHook?: TPullstateAsyncPostActionHook<A, R, T, N, S>;
  subsetKey?: (args: A) => any;
  actionId?: string | number;
}
interface IUseDebouncedExecutionOptions<A, R, T extends string, N, S extends IPullstateAllStores> {
  validInput?: (args: A) => boolean;
  equality?: ((argsPrev: A, argsNew: A) => boolean) | any;
  executeOptions?: Omit<IAsyncActionRunOptions<A, R, T, N, S>, "key" | "cacheBreak">;
  watchLastValid?: boolean;
}
type TRunWithPayload<R> = (func: (payload: R) => any) => any;
interface IBaseObjResponseUse<A, R, T extends string, N, S extends IPullstateAllStores> {
  execute: (runOptions?: IAsyncActionRunOptions<A, R, T, N, S>) => TPullstateAsyncRunResponse<R, T, N>;
}
interface IBaseObjResponseUseDefer<A, R, T extends string, N, S extends IPullstateAllStores> {
  execute: (args?: A, runOptions?: Omit<IAsyncActionRunOptions<A, R, T, N, S>, "key" | "cacheBreak">) => TPullstateAsyncRunResponse<R, T, N>;
  hasCached: (args?: A, options?: {
    successOnly?: boolean;
  } & Omit<IAsyncActionGetCachedOptions<A, R, T, N, S>, "key">) => boolean;
  unwatchExecuted: () => void;
  useDebouncedExecution: (args: A, delay: number, options?: IUseDebouncedExecutionOptions<A, R, T, N, S>) => void;
  args: A;
  key: string;
}
interface IBaseObjResponse<R, T extends string, N> {
  isLoading: boolean;
  isFinished: boolean;
  isUpdating: boolean;
  isStarted: boolean;
  clearCached: () => void;
  updateCached: (updater: TUpdateFunction<R>, options?: IAsyncActionUpdateCachedOptions) => void;
  setCached: (result: TAsyncActionResult<R, T, N>, options?: IAsyncActionSetOrClearCachedValueOptions) => void;
  setCachedPayload: (payload: R, options?: IAsyncActionSetOrClearCachedValueOptions) => void;
  endTags: (T | EAsyncEndTags)[];
  renderPayload: TRunWithPayload<R>;
  message: string;
  raw: TPullstateAsyncWatchResponse<R, T, N>;
}
interface IBaseObjSuccessResponse<R, T extends string, N> extends IBaseObjResponse<R, T, N> {
  payload: R;
  errorPayload: null;
  error: false;
  isSuccess: true;
  isFailure: false;
}
interface IBaseObjErrorResponse<R, T extends string, N> extends IBaseObjResponse<R, T, N> {
  payload: null;
  errorPayload: N;
  error: true;
  isFailure: true;
  isSuccess: false;
}
type TUseResponse<A = any, R = any, T extends string = string, N = any, S extends IPullstateAllStores = IPullstateAllStores> = (IBaseObjSuccessResponse<R, T, N> | IBaseObjErrorResponse<R, T, N>) & IBaseObjResponseUse<A, R, T, N, S>;
type TUseDeferResponse<A = any, R = any, T extends string = string, N = any, S extends IPullstateAllStores = IPullstateAllStores> = (IBaseObjSuccessResponse<R, T, N> | IBaseObjErrorResponse<R, T, N>) & IBaseObjResponseUseDefer<A, R, T, N, S>;
//#endregion
//#region src/PullstateCore.d.ts
interface IPullstateAllStores {
  [storeName: string]: Store<any>;
}
declare const PullstateContext: react0.Context<PullstateInstance<any> | null>;
declare const PullstateProvider: <T extends IPullstateAllStores>({
  instance,
  children
}: {
  instance: PullstateInstance<T>;
  children?: any;
}) => JSX.Element;
type TMultiStoreAction<P extends PullstateSingleton<S>, S extends IPullstateAllStores = (P extends PullstateSingleton<infer ST> ? ST : any)> = (update: TMultiStoreUpdateMap<S>) => void;
interface IPullstateSingletonOptions {
  asyncActions?: {
    defaultCachingSeconds?: number;
  };
}
declare class PullstateSingleton<S extends IPullstateAllStores = IPullstateAllStores> {
  options: IPullstateSingletonOptions;
  constructor(allStores: S, options?: IPullstateSingletonOptions);
  instantiate({
    hydrateSnapshot,
    ssr,
    customContext
  }?: {
    hydrateSnapshot?: IPullstateSnapshot;
    ssr?: boolean;
    customContext?: any;
  }): PullstateInstance<S>;
  useStores(): S;
  useInstance(): PullstateInstance<S>;
  createAsyncActionDirect<A extends any = any, R extends any = any, N extends any = any>(action: (args: A) => Promise<R>, options?: ICreateAsyncActionOptions<A, R, string, N, S>): IOCreateAsyncActionOutput<A, R, string, N, S>;
  createAsyncAction<A = any, R = any, T extends string = string, N extends any = any>(action: TPullstateAsyncAction<A, R, T, N, S>, options?: ICreateAsyncActionOptions<A, R, T, N, S>): IOCreateAsyncActionOutput<A, R, T, N, S>;
}
type TMultiStoreUpdateMap<S extends IPullstateAllStores> = { [K in keyof S]: (updater: TUpdateFunction<S[K] extends Store<infer T> ? T : any>) => void };
interface IPullstateSnapshot {
  allState: {
    [storeName: string]: any;
  };
  asyncResults: IPullstateAsyncResultState;
  asyncActionOrd: IPullstateAsyncActionOrdState;
}
interface IPullstateInstanceConsumable<T extends IPullstateAllStores = IPullstateAllStores> {
  stores: T;
  hasAsyncStateToResolve(): boolean;
  resolveAsyncState(): Promise<void>;
  getPullstateSnapshot(): IPullstateSnapshot;
  hydrateFromSnapshot(snapshot: IPullstateSnapshot): void;
  runAsyncAction<A, R, X extends string, N>(asyncAction: IOCreateAsyncActionOutput<A, R, X, N, T>, args?: A, runOptions?: Pick<IAsyncActionRunOptions<A, R, X, N, T>, "ignoreShortCircuit" | "respectCache">): TPullstateAsyncRunResponse<R, X, N>;
}
declare class PullstateInstance<T extends IPullstateAllStores = IPullstateAllStores> implements IPullstateInstanceConsumable<T> {
  private _ssr;
  private _customContext;
  private readonly _stores;
  _asyncCache: IPullstateAsyncCache;
  constructor(allStores: T, ssr: boolean, customContext: any);
  private getAllUnresolvedAsyncActions;
  instantiateReactions(): void;
  getPullstateSnapshot(): IPullstateSnapshot;
  resolveAsyncState(): Promise<void>;
  hasAsyncStateToResolve(): boolean;
  get stores(): T;
  get customContext(): any;
  runAsyncAction<A, R, X extends string, N>(asyncAction: IOCreateAsyncActionOutput<A, R, X, N, T>, args?: A, runOptions?: Pick<IAsyncActionRunOptions<A, R, X, N, T>, "ignoreShortCircuit" | "respectCache">): TPullstateAsyncRunResponse<R, X, N>;
  hydrateFromSnapshot(snapshot: IPullstateSnapshot): void;
}
declare function createPullstateCore<T extends IPullstateAllStores = IPullstateAllStores>(allStores?: T, options?: IPullstateSingletonOptions): PullstateSingleton<T>;
declare function useStores<T extends IPullstateAllStores = {}>(): T;
declare function useInstance<T extends IPullstateAllStores = IPullstateAllStores>(): PullstateInstance<T>;
//#endregion
//#region src/async.d.ts
declare function successResult<R, T extends string = string>(payload?: R, tags?: (EAsyncEndTags | T)[], message?: string): IAsyncActionResultPositive<R, T>;
declare function errorResult<T extends string = string, N = unknown>(tags?: (EAsyncEndTags | T)[], message?: string, errorPayload?: N): IAsyncActionResultNegative<T, N>;
declare function createAsyncActionDirect<A extends any = any, R extends any = any, N extends any = any, S extends IPullstateAllStores = IPullstateAllStores>(action: (args: A, stores: S, customContext: any) => Promise<R>, options?: ICreateAsyncActionOptions<A, R, string, N, S>): IOCreateAsyncActionOutput<A, R, string, N, S>;
declare function createAsyncAction<A = any, R = any, T extends string = string, N extends any = any, S extends IPullstateAllStores = IPullstateAllStores>(action: TPullstateAsyncAction<A, R, T, N, S>, {
  forceContext,
  shortCircuitHook,
  cacheBreakHook,
  postActionHook,
  subsetKey,
  actionId
}?: ICreateAsyncActionOptions<A, R, T, N, S>): IOCreateAsyncActionOutput<A, R, T, N, S>;
//#endregion
//#region src/InjectAsyncAction.d.ts
declare enum EAsyncActionInjectType {
  WATCH = "watch",
  BECKON = "beckon",
}
interface IPropsInjectAsyncActionBase<A, R, T extends string, N> {
  action: IOCreateAsyncActionOutput<A, R, T, N>;
  args?: A;
}
interface IPropsInjectAsyncActionBeckon<A = any, R = any, T extends string = string, N = any, S extends IPullstateAllStores = IPullstateAllStores> extends IPropsInjectAsyncActionBase<A, R, T, N> {
  type: EAsyncActionInjectType.BECKON;
  options?: IAsyncActionBeckonOptions<A, R, T, N, S>;
  children: (response: TPullstateAsyncBeckonResponse<R, T>) => ReactElement;
}
interface IPropsInjectAsyncActionWatch<A = any, R = any, T extends string = string, N = any, S extends IPullstateAllStores = IPullstateAllStores> extends IPropsInjectAsyncActionBase<A, R, T, N> {
  type: EAsyncActionInjectType.WATCH;
  children: (response: TPullstateAsyncWatchResponse<R, T, N>) => ReactElement;
  options?: IAsyncActionWatchOptions<A, R, T, N, S>;
}
type TInjectAsyncActionProps = IPropsInjectAsyncActionBeckon | IPropsInjectAsyncActionWatch;
declare function InjectAsyncAction(props: TInjectAsyncActionProps): ReactElement;
//#endregion
//#region src/reduxDevtools.d.ts
interface IORegisterInDevtoolsOptions {
  namespace?: string;
}
declare function registerInDevtools(stores: IPullstateAllStores, {
  namespace
}?: IORegisterInDevtoolsOptions): void;
//#endregion
//#region src/useLocalStore.d.ts
declare function useLocalStore<S extends object>(initialState: (() => S) | S, deps?: ReadonlyArray<any>): Store<S>;
//#endregion
//#region src/batch.d.ts
interface IBatchState {
  uiBatchFunction: ((updates: () => void) => void);
}
declare function setupBatch({
  uiBatchFunction
}: IBatchState): void;
declare function batch(runUpdates: () => void): void;
//#endregion
export { EAsyncActionInjectType, EAsyncEndTags, EPostActionContext, IAsyncActionBeckonOptions, IAsyncActionGetCachedOptions, IAsyncActionReadOptions, IAsyncActionResultNegative, IAsyncActionResultPositive, IAsyncActionRunOptions, IAsyncActionSetOrClearCachedValueOptions, IAsyncActionUpdateCachedOptions, IAsyncActionUseDeferOptions, IAsyncActionUseOptions, IAsyncActionWatchOptions, IAsyncClearCacheOptions, IBaseObjErrorResponse, IBaseObjResponse, IBaseObjResponseUse, IBaseObjResponseUseDefer, IBaseObjSuccessResponse, ICreateAsyncActionOptions, IGetCachedResponse, IOCreateAsyncActionOutput, IPullstateAllStores, IPullstateAsyncActionOrdState, IPullstateAsyncCache, IPullstateAsyncResultState, IPullstateInstanceConsumable, IUseDebouncedExecutionOptions, InjectAsyncAction, InjectStoreState, PullstateContext, PullstateProvider, type PullstateSingleton, Store, TAsyncActionBeckon, TAsyncActionClearAllCache, TAsyncActionClearAllUnwatchedCache, TAsyncActionClearCache, TAsyncActionDelayedRun, TAsyncActionGetCached, TAsyncActionRead, TAsyncActionResult, TAsyncActionRun, TAsyncActionSetCached, TAsyncActionSetCachedPayload, TAsyncActionUpdateCached, TAsyncActionUse, TAsyncActionUseDefer, TAsyncActionWatch, TInjectAsyncActionProps, TMultiStoreAction, TPullstateAsyncAction, TPullstateAsyncBeckonResponse, TPullstateAsyncCacheBreakHook, TPullstateAsyncPostActionHook, TPullstateAsyncRunResponse, TPullstateAsyncShortCircuitHook, TPullstateAsyncWatchResponse, TRunWithPayload, TStoreAction, TUpdateFunction, TUseDeferResponse, TUseResponse, batch, createAsyncAction, createAsyncActionDirect, createPullstateCore, errorResult, registerInDevtools, setupBatch, successResult, update, useInstance, useLocalStore, useStoreState, useStores };