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 Preact from "preact";
import { Context } from "preact";
import * as PreactHooks from "preact/hooks";

//#region src/preact-context.d.ts
/** A Preact context whose provider only accepts stable values. */
type StableContext<T> = Context<Stable<T>>;
/** Create a Preact context whose Provider rejects unbranded reference values. */
declare function createStableContext<T>(defaultValue: Stable<T>): StableContext<T>;
//#endregion
//#region src/preact-hooks.d.ts
type Dispatch<A> = (value: A) => void;
type StateUpdater<S> = S | ((previousState: S) => S);
type EffectCallback = () => void | (() => void);
type StrictEffectHook = {
  (effect: EffectCallback): void;
  (effect: EffectCallback, inputs: undefined): void;
  <const D extends readonly unknown[]>(effect: EffectCallback, inputs: CheckedDeps<D>): void;
};
type StrictImperativeHandle = {
  <T, R extends T>(ref: Preact.Ref<T>, create: () => R): void;
  <T, R extends T>(ref: Preact.Ref<T>, create: () => R, inputs: undefined): void;
  <T, R extends T, const D extends readonly unknown[]>(ref: Preact.Ref<T>, create: () => R, inputs: CheckedDeps<D>): void;
};
declare const useMemo: <T, const D extends readonly unknown[]>(factory: () => T, inputs: CheckedDeps<D>) => Stable<T>;
declare const useCallback: <F extends (...args: any[]) => any, const D extends readonly unknown[]>(callback: F, inputs: CheckedDeps<D>) => Stable<F>;
declare const useEffect: StrictEffectHook;
declare const useLayoutEffect: StrictEffectHook;
declare const useImperativeHandle: StrictImperativeHandle;
type StrictStateHook = {
  <S>(initialState: S | (() => S)): [Stable<S>, Stable<Dispatch<StateUpdater<S>>>];
  <S = undefined>(): [Stable<S | undefined>, Stable<Dispatch<StateUpdater<S | undefined>>>];
};
declare const useState: StrictStateHook;
type StrictReducerHook = {
  <S, A>(reducer: PreactHooks.Reducer<S, A>, initialState: S): [Stable<S>, Stable<Dispatch<A>>];
  <S, A, I>(reducer: PreactHooks.Reducer<S, A>, initialArg: I, init: (arg: I) => S): [Stable<S>, Stable<Dispatch<A>>];
};
declare const useReducer: StrictReducerHook;
type StrictRefHook = {
  <T>(initialValue: T): Stable<{
    current: T;
  }>;
  <T>(initialValue: T | null): Stable<Preact.RefObject<T>>;
  <T = undefined>(): Stable<{
    current: T | undefined;
  }>;
};
declare const useRef: StrictRefHook;
//#endregion
export { type Primitive, type Stable, type StableContext, type StableDependency, type StableDeps, createStableContext, stable, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useReducer, useRef, useState };