import { a as stable, i as StableDeps, n as Stable, r as StableDependency, t as Primitive } from "./core-DN1BZm7Y.mjs";
import { t as CheckedDeps } from "./strict-deps-C8RGmSxZ.mjs";
import * as React from "react";
import { Context } from "react";

//#region src/react-context.d.ts
/** A context whose provider and consumers agree that its value is stable. */
type StableContext<T> = Context<Stable<T>>;
/** Create a context whose Provider rejects unbranded reference values. */
declare function createStableContext<T>(defaultValue: Stable<T>): StableContext<T>;
//#endregion
//#region src/react-hooks.d.ts
type StrictEffectHook = {
  (effect: React.EffectCallback): void;
  (effect: React.EffectCallback, dependencies: undefined): void;
  <const D extends readonly unknown[]>(effect: React.EffectCallback, dependencies: CheckedDeps<D>): void;
};
type StrictImperativeHandle = {
  <T, R extends T>(ref: React.Ref<T> | undefined, init: () => R): void;
  <T, R extends T>(ref: React.Ref<T> | undefined, init: () => R, dependencies: undefined): void;
  <T, R extends T, const D extends readonly unknown[]>(ref: React.Ref<T> | undefined, init: () => R, dependencies: CheckedDeps<D>): void;
};
/** The original React hook reference with a proof-producing signature. */
declare const useMemo: <T, const D extends readonly unknown[]>(factory: () => T, dependencies: CheckedDeps<D>) => Stable<T>;
/** The original React hook reference with a proof-producing signature. */
declare const useCallback: <F extends (...args: any[]) => any, const D extends readonly unknown[]>(callback: F, dependencies: CheckedDeps<D>) => Stable<F>;
/** Effects without a list still run every render; supplied lists are checked. */
declare const useEffect: StrictEffectHook;
declare const useLayoutEffect: StrictEffectHook;
declare const useInsertionEffect: StrictEffectHook;
declare const useImperativeHandle: StrictImperativeHandle;
type StrictStateHook = {
  <S>(initialState: S | (() => S)): [Stable<S>, Stable<React.Dispatch<React.SetStateAction<S>>>];
  <S = undefined>(): [Stable<S | undefined>, Stable<React.Dispatch<React.SetStateAction<S | undefined>>>];
};
declare const useState: StrictStateHook;
type StrictReducerHook = {
  <S>(reducer: React.ReducerWithoutAction<S>, initialState: S): [Stable<S>, Stable<React.DispatchWithoutAction>];
  <S, I>(reducer: React.ReducerWithoutAction<S>, initialArg: I, init: (arg: I) => S): [Stable<S>, Stable<React.DispatchWithoutAction>];
  <S, A>(reducer: React.Reducer<S, A>, initialState: S): [Stable<S>, Stable<React.Dispatch<A>>];
  <S, I, A>(reducer: React.Reducer<S, A>, initialArg: I, init: (arg: I) => S): [Stable<S>, Stable<React.Dispatch<A>>];
};
declare const useReducer: StrictReducerHook;
type StrictRefHook = {
  <T>(initialValue: T): Stable<React.RefObject<T>>;
  <T>(initialValue: T | null): Stable<React.RefObject<T | null>>;
  <T>(initialValue: T | undefined): Stable<React.RefObject<T | undefined>>;
};
declare const useRef: StrictRefHook;
declare const useTransition: () => [boolean, Stable<React.TransitionStartFunction>];
//#endregion
export { type Primitive, type Stable, type StableContext, type StableDependency, type StableDeps, createStableContext, stable, useCallback, useEffect, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useTransition };