@lowentry/react-redux 1.16.1 → 2.0.1

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Low Entry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

package/dist/index.d.ts

@@ -0,0 +1,453 @@
+import * as _redux_saga_types from '@redux-saga/types';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import * as ReactRedux from 'react-redux';
+import * as Redux from 'redux';
+import * as RTK from '@reduxjs/toolkit';
+import * as ReduxSaga from 'redux-saga';
+import * as ReduxSagaEffects from 'redux-saga/effects';
+
+type EffectCallback = React.EffectCallback;
+type DependencyList = React.DependencyList;
+interface StoreConfig {
+    slices?: RTK.Slice[] | Record<string, RTK.Slice> | unknown[];
+    reducer?: Redux.Reducer | Redux.ReducersMapObject | unknown;
+    state?: unknown;
+    preloadedState?: unknown;
+    middleware?: unknown[] | ((getDefaultMiddleware: unknown) => unknown);
+    devTools?: boolean | unknown;
+    enhancers?: unknown[];
+    [key: string]: unknown;
+}
+interface SliceConfig {
+    name?: string;
+    state: unknown | (() => unknown);
+    actions?: Record<string, unknown>;
+    reducers?: Record<string, unknown>;
+    selectors?: Record<string, (state: unknown) => unknown>;
+    getters?: Record<string, (...args: unknown[]) => (state: unknown) => unknown>;
+    sagaListeners?: Record<string, unknown>;
+    sagas?: Record<string, unknown>;
+    __lowentry_unfinished_slice?: boolean;
+}
+declare const useState: typeof React.useState;
+declare const leRedUseSelector: <TState = unknown, TSelected = unknown>(selector: (state: TState) => TSelected, equalsComparator?: unknown) => TSelected;
+declare const leRedUseLayoutEffect: (callable: React.EffectCallback, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const leRedUseEffect: (callable: React.EffectCallback, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const leRedUseMemo: <T extends unknown>(callable: () => T, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => T;
+declare const leRedUseCallback: <T extends (...args: any[]) => any>(callable: T, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => T;
+declare const useEffect: (callable: React.EffectCallback, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useLayoutEffect: (callable: React.EffectCallback, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useCallback: <T extends (...args: any[]) => any>(callable: T, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => T;
+declare const useMemo: <T extends unknown>(callable: () => T, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => T;
+declare const useContext: typeof React.useContext;
+declare const useReducer: typeof React.useReducer;
+declare const useRef: typeof React.useRef;
+declare const useDebugValue: typeof React.useDebugValue;
+declare function useImperativeHandle<T>(ref: React.Ref<T>, createHandle: () => T, comparingValues?: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean): void;
+declare function useDeferredValue<T>(value: T, equalsComparator?: (a: unknown, b: unknown) => boolean): T;
+declare const useTransition: typeof React.useTransition;
+declare const useId: typeof React.useId;
+declare const useInsertionEffect: (callable: React.EffectCallback, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useSyncExternalStore: typeof React.useSyncExternalStore;
+declare const Children: {
+    map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Array<Exclude<T, boolean | null | undefined>>;
+    forEach<C>(children: C | readonly C[], fn: (child: C, index: number) => void): void;
+    count(children: any): number;
+    only<C>(children: C): C extends any[] ? never : C;
+    toArray(children: React.ReactNode | React.ReactNode[]): Array<Exclude<React.ReactNode, boolean | null | undefined>>;
+};
+declare const createContext: typeof React.createContext;
+declare const createElement: typeof React.createElement;
+declare const cloneElement: typeof React.cloneElement;
+declare const isValidElement: typeof React.isValidElement;
+declare const lazy: typeof React.lazy;
+declare const forwardRef: typeof React.forwardRef;
+declare const leRedMemo: <T extends React.ComponentType<any>>(component: T, equalsComparator?: (a: unknown, b: unknown) => boolean) => React.MemoExoticComponent<T>;
+declare const memo: <T extends React.ComponentType<any>>(component: T, equalsComparator?: (a: unknown, b: unknown) => boolean) => React.MemoExoticComponent<T>;
+declare const startTransition: typeof React.startTransition;
+declare const createPortal: typeof ReactDOM.createPortal;
+declare const flushSync: typeof ReactDOM.flushSync;
+declare const createReducer: typeof RTK.createReducer;
+declare const createAsyncThunk: RTK.CreateAsyncThunkFunction<RTK.AsyncThunkConfig> & {
+    withTypes<ThunkApiConfig extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T ? { [K in keyof T]: T[K]; } : never> & {
+        withTypes<ThunkApiConfig_1 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_2 ? { [K in keyof T_2]: T_2[K]; } : never, keyof ThunkApiConfig_1> extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never> & {
+            withTypes<ThunkApiConfig_2 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_5 ? { [K in keyof T_5]: T_5[K]; } : never, keyof ThunkApiConfig_1> extends infer T_4 ? { [K_1 in keyof T_4]: T_4[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_3 ? { [K_2 in keyof T_3]: T_3[K_2]; } : never> & {
+                withTypes<ThunkApiConfig_3 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_9 ? { [K in keyof T_9]: T_9[K]; } : never, keyof ThunkApiConfig_1> extends infer T_8 ? { [K_1 in keyof T_8]: T_8[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_7 ? { [K_2 in keyof T_7]: T_7[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_6 ? { [K_3 in keyof T_6]: T_6[K_3]; } : never> & {
+                    withTypes<ThunkApiConfig_4 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_14 ? { [K in keyof T_14]: T_14[K]; } : never, keyof ThunkApiConfig_1> extends infer T_13 ? { [K_1 in keyof T_13]: T_13[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_12 ? { [K_2 in keyof T_12]: T_12[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_11 ? { [K_3 in keyof T_11]: T_11[K_3]; } : never, keyof ThunkApiConfig_4> extends infer T_10 ? { [K_4 in keyof T_10]: T_10[K_4]; } : never> & {
+                        withTypes<ThunkApiConfig_5 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_20 ? { [K in keyof T_20]: T_20[K]; } : never, keyof ThunkApiConfig_1> extends infer T_19 ? { [K_1 in keyof T_19]: T_19[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_18 ? { [K_2 in keyof T_18]: T_18[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_17 ? { [K_3 in keyof T_17]: T_17[K_3]; } : never, keyof ThunkApiConfig_4> extends infer T_16 ? { [K_4 in keyof T_16]: T_16[K_4]; } : never, keyof ThunkApiConfig_5> extends infer T_15 ? { [K_5 in keyof T_15]: T_15[K_5]; } : never> & {
+                            withTypes<ThunkApiConfig_6 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_27 ? { [K in keyof T_27]: T_27[K]; } : never, keyof ThunkApiConfig_1> extends infer T_26 ? { [K_1 in keyof T_26]: T_26[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_25 ? { [K_2 in keyof T_25]: T_25[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_24 ? { [K_3 in keyof T_24]: T_24[K_3]; } : never, keyof ThunkApiConfig_4> extends infer T_23 ? { [K_4 in keyof T_23]: T_23[K_4]; } : never, keyof ThunkApiConfig_5> extends infer T_22 ? { [K_5 in keyof T_22]: T_22[K_5]; } : never, keyof ThunkApiConfig_6> extends infer T_21 ? { [K_6 in keyof T_21]: T_21[K_6]; } : never> & {
+                                withTypes<ThunkApiConfig_7 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_35 ? { [K in keyof T_35]: T_35[K]; } : never, keyof ThunkApiConfig_1> extends infer T_34 ? { [K_1 in keyof T_34]: T_34[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_33 ? { [K_2 in keyof T_33]: T_33[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_32 ? { [K_3 in keyof T_32]: T_32[K_3]; } : never, keyof ThunkApiConfig_4> extends infer T_31 ? { [K_4 in keyof T_31]: T_31[K_4]; } : never, keyof ThunkApiConfig_5> extends infer T_30 ? { [K_5 in keyof T_30]: T_30[K_5]; } : never, keyof ThunkApiConfig_6> extends infer T_29 ? { [K_6 in keyof T_29]: T_29[K_6]; } : never, keyof ThunkApiConfig_7> extends infer T_28 ? { [K_7 in keyof T_28]: T_28[K_7]; } : never> & {
+                                    withTypes<ThunkApiConfig_8 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_44 ? { [K in keyof T_44]: T_44[K]; } : never, keyof ThunkApiConfig_1> extends infer T_43 ? { [K_1 in keyof T_43]: T_43[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_42 ? { [K_2 in keyof T_42]: T_42[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_41 ? { [K_3 in keyof T_41]: T_41[K_3]; } : never, keyof ThunkApiConfig_4> extends infer T_40 ? { [K_4 in keyof T_40]: T_40[K_4]; } : never, keyof ThunkApiConfig_5> extends infer T_39 ? { [K_5 in keyof T_39]: T_39[K_5]; } : never, keyof ThunkApiConfig_6> extends infer T_38 ? { [K_6 in keyof T_38]: T_38[K_6]; } : never, keyof ThunkApiConfig_7> extends infer T_37 ? { [K_7 in keyof T_37]: T_37[K_7]; } : never, keyof ThunkApiConfig_8> extends infer T_36 ? { [K_8 in keyof T_36]: T_36[K_8]; } : never> & {
+                                        withTypes<ThunkApiConfig_9 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_9 & Omit<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_54 ? { [K in keyof T_54]: T_54[K]; } : never, keyof ThunkApiConfig_1> extends infer T_53 ? { [K_1 in keyof T_53]: T_53[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_52 ? { [K_2 in keyof T_52]: T_52[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_51 ? { [K_3 in keyof T_51]: T_51[K_3]; } : never, keyof ThunkApiConfig_4> extends infer T_50 ? { [K_4 in keyof T_50]: T_50[K_4]; } : never, keyof ThunkApiConfig_5> extends infer T_49 ? { [K_5 in keyof T_49]: T_49[K_5]; } : never, keyof ThunkApiConfig_6> extends infer T_48 ? { [K_6 in keyof T_48]: T_48[K_6]; } : never, keyof ThunkApiConfig_7> extends infer T_47 ? { [K_7 in keyof T_47]: T_47[K_7]; } : never, keyof ThunkApiConfig_8> extends infer T_46 ? { [K_8 in keyof T_46]: T_46[K_8]; } : never, keyof ThunkApiConfig_9> extends infer T_45 ? { [K_9 in keyof T_45]: T_45[K_9]; } : never> & {
+                                            withTypes<ThunkApiConfig_10 extends RTK.AsyncThunkConfig>(): RTK.CreateAsyncThunkFunction<ThunkApiConfig_10 & Omit<ThunkApiConfig_9 & Omit<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<RTK.AsyncThunkConfig, keyof ThunkApiConfig> extends infer T_65 ? { [K in keyof T_65]: T_65[K]; } : never, keyof ThunkApiConfig_1> extends infer T_64 ? { [K_1 in keyof T_64]: T_64[K_1]; } : never, keyof ThunkApiConfig_2> extends infer T_63 ? { [K_2 in keyof T_63]: T_63[K_2]; } : never, keyof ThunkApiConfig_3> extends infer T_62 ? { [K_3 in keyof T_62]: T_62[K_3]; } : never, keyof ThunkApiConfig_4> extends infer T_61 ? { [K_4 in keyof T_61]: T_61[K_4]; } : never, keyof ThunkApiConfig_5> extends infer T_60 ? { [K_5 in keyof T_60]: T_60[K_5]; } : never, keyof ThunkApiConfig_6> extends infer T_59 ? { [K_6 in keyof T_59]: T_59[K_6]; } : never, keyof ThunkApiConfig_7> extends infer T_58 ? { [K_7 in keyof T_58]: T_58[K_7]; } : never, keyof ThunkApiConfig_8> extends infer T_57 ? { [K_8 in keyof T_57]: T_57[K_8]; } : never, keyof ThunkApiConfig_9> extends infer T_56 ? { [K_9 in keyof T_56]: T_56[K_9]; } : never, keyof ThunkApiConfig_10> extends infer T_55 ? { [K_10 in keyof T_55]: T_55[K_10]; } : never> & /*elided*/ any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+declare const createEntityAdapter: typeof RTK.createEntityAdapter;
+declare const nanoid: (size?: number) => string;
+declare const current: <T extends unknown>(obj: T) => T;
+declare const isImmutableDefault: typeof RTK.isImmutableDefault;
+declare const unwrapResult: typeof RTK.unwrapResult;
+declare const createNextState: typeof RTK.createNextState;
+declare const produce: typeof RTK.createNextState;
+declare const freeze: typeof RTK.freeze;
+declare const isDraft: (value: any) => boolean;
+declare const original: typeof RTK.original;
+declare const combineSlices: typeof RTK.combineSlices;
+declare const createListenerMiddleware: <StateType = unknown, DispatchType extends Redux.Dispatch<Redux.Action> = RTK.ThunkDispatch<StateType, unknown, Redux.UnknownAction>, ExtraArgument = unknown>(middlewareOptions?: RTK.CreateListenerMiddlewareOptions<ExtraArgument>) => RTK.ListenerMiddlewareInstance<StateType, DispatchType, ExtraArgument>;
+declare const createDynamicMiddleware: <State = any, DispatchType extends Redux.Dispatch<Redux.UnknownAction> = Redux.Dispatch<Redux.UnknownAction>>() => RTK.DynamicMiddlewareInstance<State, DispatchType>;
+declare const autoBatchEnhancer: (options?: RTK.AutoBatchOptions) => Redux.StoreEnhancer;
+declare const isAnyOf: typeof RTK.isAnyOf;
+declare const isAllOf: typeof RTK.isAllOf;
+declare const isPending: typeof RTK.isPending;
+declare const isFulfilled: typeof RTK.isFulfilled;
+declare const isRejected: typeof RTK.isRejected;
+declare const isAsyncThunkAction: typeof RTK.isAsyncThunkAction;
+declare const isRejectedWithValue: typeof RTK.isRejectedWithValue;
+declare const combineReducers: typeof Redux.combineReducers;
+declare const applyMiddleware: typeof Redux.applyMiddleware;
+declare const compose: typeof Redux.compose;
+declare const bindActionCreators: typeof Redux.bindActionCreators;
+declare const configureStore: (storeData: StoreConfig) => RTK.EnhancedStore;
+declare const createSlice: (slice: SliceConfig) => RTK.Slice;
+declare const createFastSlice: (slice: SliceConfig) => RTK.Slice;
+declare const leRedCreateAction: <TPayload = unknown>(id: string) => RTK.ActionCreatorWithPayload<TPayload>;
+declare const leRedCreateSelector: <TResult = unknown>(selectorsGenerator: (this: unknown, stateOfSlice: unknown) => unknown[]) => ((this: unknown, stateOfSlice: unknown) => TResult);
+declare const leRedCreateCachedSelector: <TResult = unknown>(selectorsGenerator: (this: unknown, stateOfSlice: unknown) => unknown[], equalsComparator: (a: unknown, b: unknown) => boolean) => ((this: unknown, stateOfSlice: unknown) => TResult) | void;
+declare const batch: (callback: () => void) => void;
+declare const connect: ReactRedux.Connect<unknown>;
+declare const useSelector: <TState = unknown, TSelected = unknown>(selector: (state: TState) => TSelected, equalsComparator?: unknown) => TSelected;
+declare const useDispatch: ReactRedux.UseDispatch<Redux.Dispatch<Redux.UnknownAction>>;
+declare const useStore: ReactRedux.UseStore<Redux.Store<unknown, Redux.Action, unknown>>;
+declare const shallowEqual: typeof ReactRedux.shallowEqual;
+declare const eventChannel: typeof ReduxSaga.eventChannel;
+declare const buffers: {
+    none<T>(): ReduxSaga.Buffer<T>;
+    fixed<T>(limit?: number): ReduxSaga.Buffer<T>;
+    expanding<T>(limit?: number): ReduxSaga.Buffer<T>;
+    dropping<T>(limit?: number): ReduxSaga.Buffer<T>;
+    sliding<T>(limit?: number): ReduxSaga.Buffer<T>;
+};
+declare const detach: typeof ReduxSaga.detach;
+declare const END: _redux_saga_types.END;
+declare const isEnd: any;
+declare const channel: typeof ReduxSaga.channel;
+declare const multicastChannel: typeof ReduxSaga.multicastChannel;
+declare const stdChannel: typeof ReduxSaga.stdChannel;
+declare const runSaga: typeof ReduxSaga.runSaga;
+declare const useConfigureStore: (storeData: StoreConfig) => RTK.EnhancedStore;
+declare const useEffectInterval: (callable: () => void, comparingValues: unknown[], intervalMs: number, fireImmediately: boolean, equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useEffectAnimationFrameInterval: (callable: () => void, comparingValues: unknown[], intervalFrames: number, fireImmediately: boolean, equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useEffectGenerator: (callable: () => Generator<Promise<unknown>>, comparingValues: unknown[], _intervalMs?: unknown, _fireImmediately?: unknown, equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useEffectGeneratorLoop: (callable: () => Generator<Promise<unknown>>, comparingValues: unknown[], _intervalMs?: unknown, _fireImmediately?: unknown, equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useEffectShutdown: (callable: () => void, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const useEffectPageFocusLost: (callable: () => void, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+declare const usePrevious: <T extends unknown>(value: T, initialValue: T) => T;
+declare const useFont: (font: string) => boolean;
+declare const useScript: (url: string, props?: Record<string, string>) => void;
+declare const mergeRefs: <T extends unknown>(...refs: (React.Ref<T> | undefined)[]) => ((inst: T | null) => void) | null;
+declare const useTriggerable: <T = unknown>(event: string) => T;
+declare const trigger: (event: string, value: unknown) => void;
+declare const useTempState: <T extends unknown>(defaultValue: T, duration: number) => [T, (newValue: T) => void];
+declare const useHistory: (onForward: () => void, onBack: () => void) => [() => void, () => void];
+declare const useHistoryState: <T extends unknown>(initialState: T) => [boolean, () => void, () => void];
+declare const useUrlHashParams: () => [Record<string, string>, string];
+declare const useRetryingImageUrl: (url: string, options: {
+    retries?: number;
+    delay?: number | ((retries: number) => number);
+    queryParam?: string;
+}) => [string, () => void];
+declare const usePromises: <T = unknown>(callable: () => Promise<T> | Promise<T>[] | Record<string, Promise<T>>, comparingValues: unknown[]) => [T | T[] | Record<string, T> | null, boolean, string | null];
+declare const useExternal: <T = unknown>(url: string | string[] | Record<string, string>, options: {
+    retries?: number;
+    verify?: (data: unknown, response: Response) => Promise<void> | void;
+    [key: string]: unknown;
+}, responseFunction: (res: Response) => Promise<T>) => [T | T[] | Record<string, T> | null, boolean, string | null];
+declare const useExternalJson: (url: string | string[] | Record<string, string>, options: {
+    retries?: number;
+    verify?: (data: unknown, response: Response) => Promise<void> | void;
+    [key: string]: unknown;
+}) => [unknown | unknown[] | Record<string, unknown> | null, boolean, string | null];
+declare const useExternalBlob: (url: string | string[] | Record<string, string>, options: {
+    retries?: number;
+    verify?: (data: unknown, response: Response) => Promise<void> | void;
+    [key: string]: unknown;
+}) => [Blob | Blob[] | Record<string, Blob> | null, boolean, string | null];
+declare const useExternalArrayBuffer: (url: string | string[] | Record<string, string>, options: {
+    retries?: number;
+    verify?: (data: unknown, response: Response) => Promise<void> | void;
+    [key: string]: unknown;
+}) => [ArrayBuffer | ArrayBuffer[] | Record<string, ArrayBuffer> | null, boolean, string | null];
+declare const useExternalString: (url: string | string[] | Record<string, string>, options: {
+    retries?: number;
+    verify?: (data: unknown, response: Response) => Promise<void> | void;
+    [key: string]: unknown;
+}) => [string | string[] | Record<string, string> | null, boolean, string | null];
+declare const useExternalFormData: (url: string | string[] | Record<string, string>, options: {
+    retries?: number;
+    verify?: (data: unknown, response: Response) => Promise<void> | void;
+    [key: string]: unknown;
+}) => [FormData | FormData[] | Record<string, FormData> | null, boolean, string | null];
+declare const delayFrames: (frames?: number) => Generator;
+declare const interval: (callback: (stop: () => void) => Generator | Promise<void>, intervalMs: number) => Generator;
+declare const effects: {
+    delayFrames: (frames?: number) => Generator;
+    interval: (callback: (stop: () => void) => Generator | Promise<void>, intervalMs: number) => Generator;
+    take(pattern?: ReduxSagaEffects.ActionPattern): ReduxSagaEffects.TakeEffect;
+    take<A extends ReduxSaga.Action>(pattern?: ReduxSagaEffects.ActionPattern<A>): ReduxSagaEffects.TakeEffect;
+    take<T>(channel: ReduxSaga.TakeableChannel<T>, multicastPattern?: ReduxSagaEffects.Pattern<T>): ReduxSagaEffects.ChannelTakeEffect<T>;
+    takeMaybe(pattern?: ReduxSagaEffects.ActionPattern): ReduxSagaEffects.TakeEffect;
+    takeMaybe<A extends ReduxSaga.Action>(pattern?: ReduxSagaEffects.ActionPattern<A>): ReduxSagaEffects.TakeEffect;
+    takeMaybe<T>(channel: ReduxSaga.TakeableChannel<T>, multicastPattern?: ReduxSagaEffects.Pattern<T>): ReduxSagaEffects.ChannelTakeEffect<T>;
+    takeEvery<P extends ReduxSagaEffects.ActionPattern>(pattern: P, worker: (action: _redux_saga_types.ActionMatchingPattern<P>) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeEvery<P extends ReduxSagaEffects.ActionPattern, Fn extends (...args: any[]) => any>(pattern: P, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<_redux_saga_types.ActionMatchingPattern<P>, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeEvery<A extends ReduxSaga.Action>(pattern: ReduxSagaEffects.ActionPattern<A>, worker: (action: A) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeEvery<A extends ReduxSaga.Action, Fn extends (...args: any[]) => any>(pattern: ReduxSagaEffects.ActionPattern<A>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<A, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeEvery<T>(channel: ReduxSaga.TakeableChannel<T>, worker: (item: T) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeEvery<T, Fn extends (...args: any[]) => any>(channel: ReduxSaga.TakeableChannel<T>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<T, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeLatest<P extends ReduxSagaEffects.ActionPattern>(pattern: P, worker: (action: _redux_saga_types.ActionMatchingPattern<P>) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeLatest<P extends ReduxSagaEffects.ActionPattern, Fn extends (...args: any[]) => any>(pattern: P, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<_redux_saga_types.ActionMatchingPattern<P>, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeLatest<A extends ReduxSaga.Action>(pattern: ReduxSagaEffects.ActionPattern<A>, worker: (action: A) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeLatest<A extends ReduxSaga.Action, Fn extends (...args: any[]) => any>(pattern: ReduxSagaEffects.ActionPattern<A>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<A, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeLatest<T>(channel: ReduxSaga.TakeableChannel<T>, worker: (item: T) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeLatest<T, Fn extends (...args: any[]) => any>(channel: ReduxSaga.TakeableChannel<T>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<T, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeLeading<P extends ReduxSagaEffects.ActionPattern>(pattern: P, worker: (action: _redux_saga_types.ActionMatchingPattern<P>) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeLeading<P extends ReduxSagaEffects.ActionPattern, Fn extends (...args: any[]) => any>(pattern: P, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<_redux_saga_types.ActionMatchingPattern<P>, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeLeading<A extends ReduxSaga.Action>(pattern: ReduxSagaEffects.ActionPattern<A>, worker: (action: A) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeLeading<A extends ReduxSaga.Action, Fn extends (...args: any[]) => any>(pattern: ReduxSagaEffects.ActionPattern<A>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<A, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    takeLeading<T>(channel: ReduxSaga.TakeableChannel<T>, worker: (item: T) => any): ReduxSagaEffects.ForkEffect<never>;
+    takeLeading<T, Fn extends (...args: any[]) => any>(channel: ReduxSaga.TakeableChannel<T>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<T, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    put<A extends ReduxSaga.Action>(action: A): ReduxSagaEffects.PutEffect<A>;
+    put<ReturnType = any, State = any, ExtraThunkArg = any, BasicAction extends ReduxSaga.Action = ReduxSaga.Action>(action: ReduxSagaEffects.ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>): ReduxSagaEffects.PutEffect<BasicAction>;
+    put<T>(channel: ReduxSaga.PuttableChannel<T>, action: T | _redux_saga_types.END): ReduxSagaEffects.ChannelPutEffect<T>;
+    putResolve<A extends ReduxSaga.Action>(action: A): ReduxSagaEffects.PutEffect<A>;
+    putResolve<ReturnType = any, State = any, ExtraThunkArg = any, BasicAction extends ReduxSaga.Action = ReduxSaga.Action>(action: ReduxSagaEffects.ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>): ReduxSagaEffects.PutEffect<BasicAction>;
+    call<Fn extends (...args: any[]) => any>(fn: Fn, ...args: Parameters<Fn>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    call<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any; }, Name extends string>(ctxAndFnName: [Ctx, Name], ...args: Parameters<Ctx[Name]>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Ctx[Name]>>;
+    call<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any; }, Name extends string>(ctxAndFnName: {
+        context: Ctx;
+        fn: Name;
+    }, ...args: Parameters<Ctx[Name]>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Ctx[Name]>>;
+    call<Ctx, Fn extends (this: Ctx, ...args: any[]) => any>(ctxAndFn: [Ctx, Fn], ...args: Parameters<Fn>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    call<Ctx, Fn extends (this: Ctx, ...args: any[]) => any>(ctxAndFn: {
+        context: Ctx;
+        fn: Fn;
+    }, ...args: Parameters<Fn>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    apply<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any; }, Name extends string>(ctx: Ctx, fnName: Name, args: Parameters<Ctx[Name]>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Ctx[Name]>>;
+    apply<Ctx, Fn extends (this: Ctx, ...args: any[]) => any>(ctx: Ctx, fn: Fn, args: Parameters<Fn>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    cps<Fn extends (cb: ReduxSagaEffects.CpsCallback<any>) => any>(fn: Fn): ReduxSagaEffects.CpsEffect<ReturnType<Fn>>;
+    cps<Fn extends (...args: any[]) => any>(fn: (Parameters<Fn> extends infer T ? T extends Parameters<Fn> ? T extends [] ? never : T extends [...infer _, infer R] ? R : T[number] : never : never) extends ReduxSagaEffects.CpsCallback<any> ? Fn : never, ...args: ReduxSagaEffects.CpsFunctionParameters<Fn>): ReduxSagaEffects.CpsEffect<ReturnType<Fn>>;
+    cps<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => void; }, Name extends string>(ctxAndFnName: [Ctx, (Parameters<Ctx[Name] extends infer T ? T extends Ctx[Name] ? T extends (...args: any[]) => any ? T : (...args: any[]) => any : never : never> extends infer T_1 ? T_1 extends Parameters<Ctx[Name] extends infer T_2 ? T_2 extends Ctx[Name] ? T_2 extends (...args: any[]) => any ? T_2 : (...args: any[]) => any : never : never> ? T_1 extends [] ? never : T_1 extends [...infer _, infer R] ? R : T_1[number] : never : never) extends ReduxSagaEffects.CpsCallback<any> ? Name : never], ...args: ReduxSagaEffects.CpsFunctionParameters<Ctx[Name]>): ReduxSagaEffects.CpsEffect<ReturnType<Ctx[Name]>>;
+    cps<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => void; }, Name extends string>(ctxAndFnName: {
+        context: Ctx;
+        fn: (Parameters<Ctx[Name] extends infer T ? T extends Ctx[Name] ? T extends (...args: any[]) => any ? T : (...args: any[]) => any : never : never> extends infer T_1 ? T_1 extends Parameters<Ctx[Name] extends infer T_2 ? T_2 extends Ctx[Name] ? T_2 extends (...args: any[]) => any ? T_2 : (...args: any[]) => any : never : never> ? T_1 extends [] ? never : T_1 extends [...infer _, infer R] ? R : T_1[number] : never : never) extends ReduxSagaEffects.CpsCallback<any> ? Name : never;
+    }, ...args: ReduxSagaEffects.CpsFunctionParameters<Ctx[Name]>): ReduxSagaEffects.CpsEffect<ReturnType<Ctx[Name]>>;
+    cps<Ctx, Fn extends (this: Ctx, ...args: any[]) => void>(ctxAndFn: [Ctx, (Parameters<Fn> extends infer T ? T extends Parameters<Fn> ? T extends [] ? never : T extends [...infer _, infer R] ? R : T[number] : never : never) extends ReduxSagaEffects.CpsCallback<any> ? Fn : never], ...args: ReduxSagaEffects.CpsFunctionParameters<Fn>): ReduxSagaEffects.CpsEffect<ReturnType<Fn>>;
+    cps<Ctx, Fn extends (this: Ctx, ...args: any[]) => void>(ctxAndFn: {
+        context: Ctx;
+        fn: (Parameters<Fn> extends infer T ? T extends Parameters<Fn> ? T extends [] ? never : T extends [...infer _, infer R] ? R : T[number] : never : never) extends ReduxSagaEffects.CpsCallback<any> ? Fn : never;
+    }, ...args: ReduxSagaEffects.CpsFunctionParameters<Fn>): ReduxSagaEffects.CpsEffect<ReturnType<Fn>>;
+    fork<Fn extends (...args: any[]) => any>(fn: Fn, ...args: Parameters<Fn>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    fork<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any; }, Name extends string>(ctxAndFnName: [Ctx, Name], ...args: Parameters<Ctx[Name]>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Ctx[Name]>>;
+    fork<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any; }, Name extends string>(ctxAndFnName: {
+        context: Ctx;
+        fn: Name;
+    }, ...args: Parameters<Ctx[Name]>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Ctx[Name]>>;
+    fork<Ctx, Fn extends (this: Ctx, ...args: any[]) => any>(ctxAndFn: [Ctx, Fn], ...args: Parameters<Fn>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    fork<Ctx, Fn extends (this: Ctx, ...args: any[]) => any>(ctxAndFn: {
+        context: Ctx;
+        fn: Fn;
+    }, ...args: Parameters<Fn>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    spawn<Fn extends (...args: any[]) => any>(fn: Fn, ...args: Parameters<Fn>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    spawn<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any; }, Name extends string>(ctxAndFnName: [Ctx, Name], ...args: Parameters<Ctx[Name]>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Ctx[Name]>>;
+    spawn<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any; }, Name extends string>(ctxAndFnName: {
+        context: Ctx;
+        fn: Name;
+    }, ...args: Parameters<Ctx[Name]>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Ctx[Name]>>;
+    spawn<Ctx, Fn extends (this: Ctx, ...args: any[]) => any>(ctxAndFn: [Ctx, Fn], ...args: Parameters<Fn>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    spawn<Ctx, Fn extends (this: Ctx, ...args: any[]) => any>(ctxAndFn: {
+        context: Ctx;
+        fn: Fn;
+    }, ...args: Parameters<Fn>): ReduxSagaEffects.ForkEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    join(task: ReduxSaga.Task): ReduxSagaEffects.JoinEffect;
+    join(tasks: ReduxSaga.Task[]): ReduxSagaEffects.JoinEffect;
+    cancel(task: ReduxSaga.Task): ReduxSagaEffects.CancelEffect;
+    cancel(tasks: ReduxSaga.Task[]): ReduxSagaEffects.CancelEffect;
+    cancel(): ReduxSagaEffects.CancelEffect;
+    select(): ReduxSagaEffects.SelectEffect;
+    select<Fn extends (state: any, ...args: any[]) => any>(selector: Fn, ...args: ReduxSagaEffects.Tail<Parameters<Fn>>): ReduxSagaEffects.SelectEffect;
+    actionChannel(pattern: ReduxSagaEffects.ActionPattern, buffer?: ReduxSaga.Buffer<ReduxSaga.Action>): ReduxSagaEffects.ActionChannelEffect;
+    flush<T>(channel: ReduxSaga.FlushableChannel<T>): ReduxSagaEffects.FlushEffect<T>;
+    cancelled(): ReduxSagaEffects.CancelledEffect;
+    setContext<C extends object>(props: C): ReduxSagaEffects.SetContextEffect<C>;
+    getContext(prop: string): ReduxSagaEffects.GetContextEffect;
+    delay<T = true>(ms: number, val?: T): ReduxSagaEffects.CallEffect<T>;
+    throttle<P extends ReduxSagaEffects.ActionPattern>(ms: number, pattern: P, worker: (action: _redux_saga_types.ActionMatchingPattern<P>) => any): ReduxSagaEffects.ForkEffect<never>;
+    throttle<P extends ReduxSagaEffects.ActionPattern, Fn extends (...args: any[]) => any>(ms: number, pattern: P, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<_redux_saga_types.ActionMatchingPattern<P>, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    throttle<A extends ReduxSaga.Action>(ms: number, pattern: ReduxSagaEffects.ActionPattern<A>, worker: (action: A) => any): ReduxSagaEffects.ForkEffect<never>;
+    throttle<A extends ReduxSaga.Action, Fn extends (...args: any[]) => any>(ms: number, pattern: ReduxSagaEffects.ActionPattern<A>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<A, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    throttle<T>(ms: number, channel: ReduxSaga.TakeableChannel<T>, worker: (item: T) => any): ReduxSagaEffects.ForkEffect<never>;
+    throttle<T, Fn extends (...args: any[]) => any>(ms: number, channel: ReduxSaga.TakeableChannel<T>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<T, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    debounce<P extends ReduxSagaEffects.ActionPattern>(ms: number, pattern: P, worker: (action: _redux_saga_types.ActionMatchingPattern<P>) => any): ReduxSagaEffects.ForkEffect<never>;
+    debounce<P extends ReduxSagaEffects.ActionPattern, Fn extends (...args: any[]) => any>(ms: number, pattern: P, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<_redux_saga_types.ActionMatchingPattern<P>, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    debounce<A extends ReduxSaga.Action>(ms: number, pattern: ReduxSagaEffects.ActionPattern<A>, worker: (action: A) => any): ReduxSagaEffects.ForkEffect<never>;
+    debounce<A extends ReduxSaga.Action, Fn extends (...args: any[]) => any>(ms: number, pattern: ReduxSagaEffects.ActionPattern<A>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<A, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    debounce<T>(ms: number, channel: ReduxSaga.TakeableChannel<T>, worker: (item: T) => any): ReduxSagaEffects.ForkEffect<never>;
+    debounce<T, Fn extends (...args: any[]) => any>(ms: number, channel: ReduxSaga.TakeableChannel<T>, worker: Fn, ...args: ReduxSagaEffects.HelperWorkerParameters<T, Fn>): ReduxSagaEffects.ForkEffect<never>;
+    retry<Fn extends (...args: any[]) => any>(maxTries: number, delayLength: number, fn: Fn, ...args: Parameters<Fn>): ReduxSagaEffects.CallEffect<ReduxSagaEffects.SagaReturnType<Fn>>;
+    all<T>(effects: T[]): ReduxSagaEffects.AllEffect<T>;
+    all<T>(effects: {
+        [key: string]: T;
+    }): ReduxSagaEffects.AllEffect<T>;
+    race<T>(effects: {
+        [key: string]: T;
+    }): ReduxSagaEffects.RaceEffect<T>;
+    race<T>(effects: T[]): ReduxSagaEffects.RaceEffect<T>;
+    effectTypes: {
+        TAKE: "TAKE";
+        PUT: "PUT";
+        ALL: "ALL";
+        RACE: "RACE";
+        CALL: "CALL";
+        CPS: "CPS";
+        FORK: "FORK";
+        JOIN: "JOIN";
+        CANCEL: "CANCEL";
+        SELECT: "SELECT";
+        ACTION_CHANNEL: "ACTION_CHANNEL";
+        CANCELLED: "CANCELLED";
+        FLUSH: "FLUSH";
+        GET_CONTEXT: "GET_CONTEXT";
+        SET_CONTEXT: "SET_CONTEXT";
+    };
+};
+declare const Root: React.MemoExoticComponent<({ store, children, ...other }: {
+    store?: StoreConfig;
+    children?: React.ReactNode;
+    [key: string]: unknown;
+}) => React.ReactElement>;
+declare const PreloadComponent: (load: () => Promise<unknown>) => () => Promise<unknown>;
+declare const LoadComponent: React.MemoExoticComponent<({ loading, load, ...other }: {
+    loading?: React.ReactElement;
+    load: unknown;
+    [key: string]: unknown;
+}) => React.ReactElement | null>;
+interface LeRedInterface {
+    useState: typeof useState;
+    useEffect: typeof useEffect;
+    useLayoutEffect: typeof useLayoutEffect;
+    useContext: typeof useContext;
+    useReducer: typeof useReducer;
+    useCallback: typeof useCallback;
+    useMemo: typeof useMemo;
+    useRef: typeof useRef;
+    useImperativeHandle: typeof useImperativeHandle;
+    useDebugValue: typeof useDebugValue;
+    useDeferredValue: typeof useDeferredValue;
+    useTransition: typeof useTransition;
+    useSyncExternalStore: typeof useSyncExternalStore;
+    useId: typeof useId;
+    useInsertionEffect: (callable: React.EffectCallback, comparingValues: unknown[], equalsComparator?: (a: unknown, b: unknown) => boolean) => void;
+    createContext: typeof createContext;
+    createElement: typeof createElement;
+    cloneElement: typeof cloneElement;
+    isValidElement: typeof isValidElement;
+    lazy: typeof lazy;
+    forwardRef: typeof forwardRef;
+    memo: typeof memo;
+    startTransition: typeof startTransition;
+    createPortal: typeof createPortal;
+    flushSync: typeof flushSync;
+    combineReducers: typeof combineReducers;
+    applyMiddleware: typeof applyMiddleware;
+    compose: typeof compose;
+    bindActionCreators: typeof bindActionCreators;
+    configureStore: typeof configureStore;
+    createSlice: typeof createSlice;
+    createFastSlice: typeof createFastSlice;
+    createAction: typeof leRedCreateAction;
+    createReducer: typeof createReducer;
+    createAsyncThunk: typeof createAsyncThunk;
+    createEntityAdapter: typeof createEntityAdapter;
+    createSelector: typeof leRedCreateSelector;
+    createCachedSelector: typeof leRedCreateCachedSelector;
+    createNextState: typeof createNextState;
+    produce: typeof produce;
+    freeze: typeof freeze;
+    isDraft: typeof isDraft;
+    original: typeof original;
+    combineSlices: typeof combineSlices;
+    createListenerMiddleware: typeof createListenerMiddleware;
+    createDynamicMiddleware: typeof createDynamicMiddleware;
+    autoBatchEnhancer: typeof autoBatchEnhancer;
+    isAnyOf: typeof isAnyOf;
+    isAllOf: typeof isAllOf;
+    isPending: typeof isPending;
+    isFulfilled: typeof isFulfilled;
+    isRejected: typeof isRejected;
+    isAsyncThunkAction: typeof isAsyncThunkAction;
+    isRejectedWithValue: typeof isRejectedWithValue;
+    nanoid: typeof nanoid;
+    current: typeof current;
+    isImmutableDefault: typeof isImmutableDefault;
+    unwrapResult: typeof unwrapResult;
+    useSelector: typeof useSelector;
+    useDispatch: typeof useDispatch;
+    useStore: typeof useStore;
+    shallowEqual: typeof shallowEqual;
+    batch: typeof batch;
+    connect: typeof connect;
+    eventChannel: typeof eventChannel;
+    buffers: typeof buffers;
+    detach: typeof detach;
+    channel: typeof channel;
+    multicastChannel: typeof multicastChannel;
+    stdChannel: typeof stdChannel;
+    runSaga: typeof runSaga;
+    END: typeof END;
+    isEnd: typeof isEnd;
+    effects: typeof effects;
+    useConfigureStore: typeof useConfigureStore;
+    useEffectInterval: typeof useEffectInterval;
+    useEffectAnimationFrameInterval: typeof useEffectAnimationFrameInterval;
+    useEffectGenerator: typeof useEffectGenerator;
+    useEffectGeneratorLoop: typeof useEffectGeneratorLoop;
+    useEffectShutdown: typeof useEffectShutdown;
+    useEffectPageFocusLost: typeof useEffectPageFocusLost;
+    usePrevious: typeof usePrevious;
+    useFont: typeof useFont;
+    useScript: typeof useScript;
+    mergeRefs: typeof mergeRefs;
+    useTriggerable: typeof useTriggerable;
+    trigger: typeof trigger;
+    useTempState: typeof useTempState;
+    useHistory: typeof useHistory;
+    useHistoryState: typeof useHistoryState;
+    useUrlHashParams: typeof useUrlHashParams;
+    useRetryingImageUrl: typeof useRetryingImageUrl;
+    usePromises: typeof usePromises;
+    useExternal: typeof useExternal;
+    useExternalJson: typeof useExternalJson;
+    useExternalBlob: typeof useExternalBlob;
+    useExternalArrayBuffer: typeof useExternalArrayBuffer;
+    useExternalString: typeof useExternalString;
+    useExternalFormData: typeof useExternalFormData;
+    Root: typeof Root;
+    LoadComponent: typeof LoadComponent;
+    PreloadComponent: typeof PreloadComponent;
+    set?: (key: string, value: unknown) => void;
+    setAll?: (obj: unknown, optionalSkipHasOwnPropertyCheck?: boolean) => void;
+    [key: string]: any;
+}
+declare const LeRed: LeRedInterface;
+
+export { Children, type DependencyList, END, type EffectCallback, LeRed, type LeRedInterface, LoadComponent, PreloadComponent, Root, type SliceConfig, type StoreConfig, applyMiddleware, autoBatchEnhancer, batch, bindActionCreators, buffers, channel, cloneElement, combineReducers, combineSlices, compose, configureStore, connect, createAsyncThunk, createContext, createDynamicMiddleware, createElement, createEntityAdapter, createFastSlice, createListenerMiddleware, createNextState, createPortal, createReducer, createSlice, current, delayFrames, detach, effects, eventChannel, flushSync, forwardRef, freeze, interval, isAllOf, isAnyOf, isAsyncThunkAction, isDraft, isEnd, isFulfilled, isImmutableDefault, isPending, isRejected, isRejectedWithValue, isValidElement, lazy, leRedCreateAction, leRedCreateCachedSelector, leRedCreateSelector, leRedMemo, leRedUseCallback, leRedUseEffect, leRedUseLayoutEffect, leRedUseMemo, leRedUseSelector, memo, mergeRefs, multicastChannel, nanoid, original, produce, runSaga, shallowEqual, startTransition, stdChannel, trigger, unwrapResult, useCallback, useConfigureStore, useContext, useDebugValue, useDeferredValue, useDispatch, useEffect, useEffectAnimationFrameInterval, useEffectGenerator, useEffectGeneratorLoop, useEffectInterval, useEffectPageFocusLost, useEffectShutdown, useExternal, useExternalArrayBuffer, useExternalBlob, useExternalFormData, useExternalJson, useExternalString, useFont, useHistory, useHistoryState, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, usePrevious, usePromises, useReducer, useRef, useRetryingImageUrl, useScript, useSelector, useState, useStore, useSyncExternalStore, useTempState, useTransition, useTriggerable, useUrlHashParams };