mobx-react-lite

const clearTimers: any;

const Observer: typeof ObserverComponent;

enableStaticRendering: (enable: boolean) => void;

isObserverBatched: () => boolean;

isUsingStaticRendering: () => boolean;

observer: {
    <P extends object, TRef = {}>(
        baseComponent: React.ForwardRefRenderFunction<TRef, P>,
        options: IObserverOptions & { forwardRef: true }
    ): React.MemoExoticComponent<React.ForwardRefExoticComponent<any>>;
    <P extends object, TRef = {}>(
        baseComponent: React.ForwardRefExoticComponent<any>
    ): React.MemoExoticComponent<React.ForwardRefExoticComponent<any>>;
    <P extends object>(
        baseComponent: React.FunctionComponent<P>,
        options?: IObserverOptions
    ): React.FunctionComponent<P>;
    <C extends unknown, Options extends IObserverOptions>(
        baseComponent: C,
        options?: Options
    ): Options extends { forwardRef: true }
        ? C extends React.ForwardRefRenderFunction<infer TRef, infer P>
            ? any
            : never
        : C & { displayName: string };
};

Observer: typeof ObserverComponent;

observerBatching: (reactionScheduler: any) => void;

useAsObservableSource: <TSource extends object>(current: TSource) => TSource;

useLocalObservable: <TStore extends Record<string, any>>(
    initializer: () => TStore,
    annotations?: AnnotationsMap<TStore, never>
) => TStore;

useLocalStore: {
    <TStore extends Record<string, any>>(initializer: () => TStore): TStore;
    <TStore extends Record<string, any>, TSource extends object>(
        initializer: (source: TSource) => TStore,
        current: TSource
    ): TStore;
};

useObserver: <T>(fn: () => T, baseComponentName?: string) => T;

useStaticRendering: (enable: boolean) => void;