jotai

export * from './vanilla.js';
export * from './react.js';

export * from './vanilla/utils.js';
export * from './react/utils.js';

• AnyValue

  type AnyValue = unknown;

• AnyError

  type AnyError = unknown;

• AnyAtom

  type AnyAtom = Atom<AnyValue>;

• WithOnMount

  type WithOnMount<Args extends unknown[], Result> = {
      onMount: NonNullable<WritableAtom<AnyValue, Args, Result>["onMount"]>;
  };

• WithOnInit

  type WithOnInit = {
      INTERNAL_onInit: NonNullable<Atom<AnyValue>["INTERNAL_onInit"]>;
  };

• OnUnmount

  type OnUnmount = () => void;

• EpochNumber

  type EpochNumber = number;

• AtomState

  /**
   * Mutable atom state,
   * tracked for both mounted and unmounted atoms in a store.
   *
   * This should be garbage collectable.
   * We can mutate it during atom read. (except for fields with TODO)
   */
  type AtomState<Value = AnyValue> = {
      /**
       * Map of atoms that the atom depends on.
       * The map value is the epoch number of the dependency.
       */
      readonly d: Map<AnyAtom, EpochNumber>;
      /**
       * Set of atoms with pending promise that depend on the atom.
       *
       * This may cause memory leaks, but it's for the capability to continue promises
       * TODO(daishi): revisit how to handle this
       */
      readonly p: Set<AnyAtom>;
      /** The epoch number of the atom. */
      n: EpochNumber;
      /** The store epoch number that last validated the atom. */
      m?: EpochNumber;
      /** Atom value */
      v?: Value;
      /** Atom error */
      e?: AnyError;
  };

• Mounted

  /**
   * State tracked for mounted atoms. An atom is considered "mounted" if it has a
   * subscriber, or is a transitive dependency of another atom that has a
   * subscriber.
   * The mounted state of an atom is freed once it is no longer mounted.
   */
  type Mounted = {
      /** Set of listeners to notify when the atom value changes. */
      readonly l: Set<() => void>;
      /** Set of mounted atoms that the atom depends on. */
      readonly d: Set<AnyAtom>;
      /** Set of mounted atoms that depends on the atom. */
      readonly t: Set<AnyAtom>;
      /** Function to run when the atom is unmounted. */
      u?: () => void;
  };

• WeakMapLike

  type WeakMapLike<K extends object, V> = {
      get(key: K): V | undefined;
      set(key: K, value: V): void;
      has(key: K): boolean;
      delete(key: K): boolean;
  };

• SetLike

  type SetLike<T> = {
      readonly size: number;
      add(value: T): void;
      has(value: T): boolean;
      delete(value: T): boolean;
      clear(): void;
      forEach(callback: (value: T) => void): void;
      [Symbol.iterator](): IterableIterator<T>;
  };

• AtomStateMap

  type AtomStateMap = WeakMapLike<AnyAtom, AtomState>;

• MountedMap

  type MountedMap = WeakMapLike<AnyAtom, Mounted>;

• InvalidatedAtoms

  type InvalidatedAtoms = WeakMapLike<AnyAtom, EpochNumber>;

• ChangedAtoms

  type ChangedAtoms = SetLike<AnyAtom>;

• Callbacks

  type Callbacks = SetLike<() => void>;

• AtomRead

  type AtomRead = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>, ...params: Parameters<Atom<Value>["read"]>) => Value;

• AtomWrite

  type AtomWrite = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, ...params: Parameters<WritableAtom<Value, Args, Result>["write"]>) => Result;

• AtomOnInit

  type AtomOnInit = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value> & WithOnInit) => void;

• AtomOnMount

  type AtomOnMount = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result> & WithOnMount<Args, Result>, setAtom: (...args: Args) => Result) => OnUnmount | void;

• EnsureAtomState

  type EnsureAtomState = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => AtomState<Value>;

• FlushCallbacks

  type FlushCallbacks = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => void;

• RecomputeInvalidatedAtoms

  type RecomputeInvalidatedAtoms = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => void;

• ReadAtomState

  type ReadAtomState = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => AtomState<Value>;

• InvalidateDependents

  type InvalidateDependents = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom) => void;

• WriteAtomState

  type WriteAtomState = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, args: Args) => Result;

• MountDependencies

  type MountDependencies = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom) => void;

• MountAtom

  type MountAtom = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Mounted;

• UnmountAtom

  type UnmountAtom = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Mounted | undefined;

• SetAtomStateValueOrPromise

  type SetAtomStateValueOrPromise = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>, valueOrPromise: Value) => void;

• StoreGet

  type StoreGet = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Value;

• StoreSet

  type StoreSet = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;

• StoreSub

  type StoreSub = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom, listener: () => void) => () => void;

• EnhanceBuildingBlocks

  type EnhanceBuildingBlocks = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => Readonly<BuildingBlocks>;

• AbortHandlersMap

  type AbortHandlersMap = WeakMapLike<PromiseLike<unknown>, Set<() => void>>;

• RegisterAbortHandler

  type RegisterAbortHandler = <T>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, promise: PromiseLike<T>, abortHandler: () => void) => void;

• AbortPromise

  type AbortPromise = <T>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, promise: PromiseLike<T>) => void;

• StoreEpochHolder

  type StoreEpochHolder = [
      n: EpochNumber
  ];

• Store

  type Store = {
      get: <Value>(atom: Atom<Value>) => Value;
      set: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
      sub: (atom: AnyAtom, listener: () => void) => () => void;
  };

• BuildingBlocks

  type BuildingBlocks = {
      [KEY_atomStateMap]: AtomStateMap;
      [KEY_mountedMap]: MountedMap;
      [KEY_invalidatedAtoms]: InvalidatedAtoms;
      [KEY_changedAtoms]: ChangedAtoms;
      [KEY_mountCallbacks]: Callbacks;
      [KEY_unmountCallbacks]: Callbacks;
      [KEY_storeHooks]: StoreHooks;
      [KEY_atomRead]: AtomRead;
      [KEY_atomWrite]: AtomWrite;
      [KEY_atomOnInit]: AtomOnInit;
      [KEY_atomOnMount]: AtomOnMount;
      [KEY_ensureAtomState]: EnsureAtomState;
      [KEY_flushCallbacks]: FlushCallbacks;
      [KEY_recomputeInvalidatedAtoms]: RecomputeInvalidatedAtoms;
      [KEY_readAtomState]: ReadAtomState;
      [KEY_invalidateDependents]: InvalidateDependents;
      [KEY_writeAtomState]: WriteAtomState;
      [KEY_mountDependencies]: MountDependencies;
      [KEY_mountAtom]: MountAtom;
      [KEY_unmountAtom]: UnmountAtom;
      [KEY_setAtomStateValueOrPromise]: SetAtomStateValueOrPromise;
      [KEY_storeGet]: StoreGet;
      [KEY_storeSet]: StoreSet;
      [KEY_storeSub]: StoreSub;
      [KEY_enhanceBuildingBlocks]: EnhanceBuildingBlocks | undefined;
      [KEY_abortHandlersMap]: AbortHandlersMap;
      [KEY_registerAbortHandler]: RegisterAbortHandler;
      [KEY_abortPromise]: AbortPromise;
      [KEY_storeEpochHolder]: StoreEpochHolder;
  };

• ActuallyWritableAtom

  type ActuallyWritableAtom<T extends AnyAtom> = T extends WritableAtom<infer V, infer A, infer R> ? T & WritableAtom<V, A, R> : T extends Atom<infer V> ? T & WritableAtom<V, unknown[], unknown> : never;

• StoreHook

  type StoreHook = {
      (): void;
      add(callback: () => void): () => void;
  };

• StoreHookForAtoms

  type StoreHookForAtoms = {
      (atom: AnyAtom): void;
      add(atom: AnyAtom, callback: () => void): () => void;
      add(atom: undefined, callback: (atom: AnyAtom) => void): () => void;
  };

• StoreHooks

  /** StoreHooks are an experimental API. */
  type StoreHooks = {
      /** Listener to notify when the atom state is created. */
      readonly i?: StoreHookForAtoms;
      /** Listener to notify when the atom is read. */
      readonly r?: StoreHookForAtoms;
      /** Listener to notify when the atom value is changed. */
      readonly c?: StoreHookForAtoms;
      /** Listener to notify when the atom is mounted. */
      readonly m?: StoreHookForAtoms;
      /** Listener to notify when the atom is unmounted. */
      readonly u?: StoreHookForAtoms;
      /** Listener to notify when callbacks are being flushed. */
      readonly f?: StoreHook;
  };

• hasInitialValue

  declare function hasInitialValue<T extends AnyAtom>(atom: T): atom is T & (T extends Atom<infer Value> ? {
      init: Value;
  } : never);

• isActuallyWritableAtom

  declare function isActuallyWritableAtom<T extends AnyAtom>(atom: T): atom is ActuallyWritableAtom<T>;

• isAtomStateInitialized

  declare function isAtomStateInitialized(atomState: AtomState<AnyValue>): boolean;

• returnAtomValue

  declare function returnAtomValue<Value>(atomState: AtomState<Value>): Value;

• isPromiseLike

  declare function isPromiseLike(p: unknown): p is PromiseLike<unknown>;

• shouldThrowSynchronously

  declare function shouldThrowSynchronously(error: unknown): boolean;

• addPendingPromiseToDependency

  declare function addPendingPromiseToDependency(atom: AnyAtom, promise: PromiseLike<AnyValue>, dependencyAtomState: AtomState): void;

• getMountedOrPendingDependents

  declare function getMountedOrPendingDependents(atom: AnyAtom, atomState: AtomState, mountedMap: MountedMap): Iterable<AnyAtom>;

• initializeStoreHooks

  declare function initializeStoreHooks(storeHooks: StoreHooks): Required<StoreHooks>;

• getBuildingBlocks

  declare function getBuildingBlocks(store: Store): Readonly<BuildingBlocks>;

• buildStore

  declare function buildStore(partialBuildingBlocks?: Partial<BuildingBlocks>): Store;

import type { Atom, WritableAtom } from './atom.js';
type AnyValue = unknown;
type AnyError = unknown;
type AnyAtom = Atom<AnyValue>;
type WithOnMount<Args extends unknown[], Result> = {
    onMount: NonNullable<WritableAtom<AnyValue, Args, Result>['onMount']>;
};
type WithOnInit = {
    INTERNAL_onInit: NonNullable<Atom<AnyValue>['INTERNAL_onInit']>;
};
type OnUnmount = () => void;
type EpochNumber = number;
/**
 * Mutable atom state,
 * tracked for both mounted and unmounted atoms in a store.
 *
 * This should be garbage collectable.
 * We can mutate it during atom read. (except for fields with TODO)
 */
type AtomState<Value = AnyValue> = {
    /**
     * Map of atoms that the atom depends on.
     * The map value is the epoch number of the dependency.
     */
    readonly d: Map<AnyAtom, EpochNumber>;
    /**
     * Set of atoms with pending promise that depend on the atom.
     *
     * This may cause memory leaks, but it's for the capability to continue promises
     * TODO(daishi): revisit how to handle this
     */
    readonly p: Set<AnyAtom>;
    /** The epoch number of the atom. */
    n: EpochNumber;
    /** The store epoch number that last validated the atom. */
    m?: EpochNumber;
    /** Atom value */
    v?: Value;
    /** Atom error */
    e?: AnyError;
};
/**
 * State tracked for mounted atoms. An atom is considered "mounted" if it has a
 * subscriber, or is a transitive dependency of another atom that has a
 * subscriber.
 * The mounted state of an atom is freed once it is no longer mounted.
 */
type Mounted = {
    /** Set of listeners to notify when the atom value changes. */
    readonly l: Set<() => void>;
    /** Set of mounted atoms that the atom depends on. */
    readonly d: Set<AnyAtom>;
    /** Set of mounted atoms that depends on the atom. */
    readonly t: Set<AnyAtom>;
    /** Function to run when the atom is unmounted. */
    u?: () => void;
};
type WeakMapLike<K extends object, V> = {
    get(key: K): V | undefined;
    set(key: K, value: V): void;
    has(key: K): boolean;
    delete(key: K): boolean;
};
type SetLike<T> = {
    readonly size: number;
    add(value: T): void;
    has(value: T): boolean;
    delete(value: T): boolean;
    clear(): void;
    forEach(callback: (value: T) => void): void;
    [Symbol.iterator](): IterableIterator<T>;
};
type AtomStateMap = WeakMapLike<AnyAtom, AtomState>;
type MountedMap = WeakMapLike<AnyAtom, Mounted>;
type InvalidatedAtoms = WeakMapLike<AnyAtom, EpochNumber>;
type ChangedAtoms = SetLike<AnyAtom>;
type Callbacks = SetLike<() => void>;
type AtomRead = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>, ...params: Parameters<Atom<Value>['read']>) => Value;
type AtomWrite = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, ...params: Parameters<WritableAtom<Value, Args, Result>['write']>) => Result;
type AtomOnInit = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value> & WithOnInit) => void;
type AtomOnMount = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result> & WithOnMount<Args, Result>, setAtom: (...args: Args) => Result) => OnUnmount | void;
type EnsureAtomState = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => AtomState<Value>;
type FlushCallbacks = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => void;
type RecomputeInvalidatedAtoms = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => void;
type ReadAtomState = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => AtomState<Value>;
type InvalidateDependents = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom) => void;
type WriteAtomState = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, args: Args) => Result;
type MountDependencies = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom) => void;
type MountAtom = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Mounted;
type UnmountAtom = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Mounted | undefined;
type SetAtomStateValueOrPromise = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>, valueOrPromise: Value) => void;
type StoreGet = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Value;
type StoreSet = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
type StoreSub = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom, listener: () => void) => () => void;
type EnhanceBuildingBlocks = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => Readonly<BuildingBlocks>;
type AbortHandlersMap = WeakMapLike<PromiseLike<unknown>, Set<() => void>>;
type RegisterAbortHandler = <T>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, promise: PromiseLike<T>, abortHandler: () => void) => void;
type AbortPromise = <T>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, promise: PromiseLike<T>) => void;
type StoreEpochHolder = [n: EpochNumber];
type Store = {
    get: <Value>(atom: Atom<Value>) => Value;
    set: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
    sub: (atom: AnyAtom, listener: () => void) => () => void;
};
declare const KEY_atomStateMap = "a";
declare const KEY_mountedMap = "m";
declare const KEY_invalidatedAtoms = "i";
declare const KEY_changedAtoms = "c";
declare const KEY_mountCallbacks = "q";
declare const KEY_unmountCallbacks = "Q";
declare const KEY_storeHooks = "h";
declare const KEY_atomRead = "R";
declare const KEY_atomWrite = "W";
declare const KEY_atomOnInit = "I";
declare const KEY_atomOnMount = "M";
declare const KEY_ensureAtomState = "e";
declare const KEY_flushCallbacks = "f";
declare const KEY_recomputeInvalidatedAtoms = "C";
declare const KEY_readAtomState = "r";
declare const KEY_invalidateDependents = "d";
declare const KEY_writeAtomState = "w";
declare const KEY_mountDependencies = "D";
declare const KEY_mountAtom = "t";
declare const KEY_unmountAtom = "T";
declare const KEY_setAtomStateValueOrPromise = "v";
declare const KEY_storeGet = "g";
declare const KEY_storeSet = "s";
declare const KEY_storeSub = "b";
declare const KEY_enhanceBuildingBlocks = "B";
declare const KEY_abortHandlersMap = "p";
declare const KEY_registerAbortHandler = "H";
declare const KEY_abortPromise = "A";
declare const KEY_storeEpochHolder = "E";
type BuildingBlocks = {
    [KEY_atomStateMap]: AtomStateMap;
    [KEY_mountedMap]: MountedMap;
    [KEY_invalidatedAtoms]: InvalidatedAtoms;
    [KEY_changedAtoms]: ChangedAtoms;
    [KEY_mountCallbacks]: Callbacks;
    [KEY_unmountCallbacks]: Callbacks;
    [KEY_storeHooks]: StoreHooks;
    [KEY_atomRead]: AtomRead;
    [KEY_atomWrite]: AtomWrite;
    [KEY_atomOnInit]: AtomOnInit;
    [KEY_atomOnMount]: AtomOnMount;
    [KEY_ensureAtomState]: EnsureAtomState;
    [KEY_flushCallbacks]: FlushCallbacks;
    [KEY_recomputeInvalidatedAtoms]: RecomputeInvalidatedAtoms;
    [KEY_readAtomState]: ReadAtomState;
    [KEY_invalidateDependents]: InvalidateDependents;
    [KEY_writeAtomState]: WriteAtomState;
    [KEY_mountDependencies]: MountDependencies;
    [KEY_mountAtom]: MountAtom;
    [KEY_unmountAtom]: UnmountAtom;
    [KEY_setAtomStateValueOrPromise]: SetAtomStateValueOrPromise;
    [KEY_storeGet]: StoreGet;
    [KEY_storeSet]: StoreSet;
    [KEY_storeSub]: StoreSub;
    [KEY_enhanceBuildingBlocks]: EnhanceBuildingBlocks | undefined;
    [KEY_abortHandlersMap]: AbortHandlersMap;
    [KEY_registerAbortHandler]: RegisterAbortHandler;
    [KEY_abortPromise]: AbortPromise;
    [KEY_storeEpochHolder]: StoreEpochHolder;
};
export type { AtomState as INTERNAL_AtomState, Mounted as INTERNAL_Mounted, AtomStateMap as INTERNAL_AtomStateMap, MountedMap as INTERNAL_MountedMap, InvalidatedAtoms as INTERNAL_InvalidatedAtoms, ChangedAtoms as INTERNAL_ChangedAtoms, Callbacks as INTERNAL_Callbacks, AtomRead as INTERNAL_AtomRead, AtomWrite as INTERNAL_AtomWrite, AtomOnInit as INTERNAL_AtomOnInit, AtomOnMount as INTERNAL_AtomOnMount, EnsureAtomState as INTERNAL_EnsureAtomState, FlushCallbacks as INTERNAL_FlushCallbacks, RecomputeInvalidatedAtoms as INTERNAL_RecomputeInvalidatedAtoms, ReadAtomState as INTERNAL_ReadAtomState, InvalidateDependents as INTERNAL_InvalidateDependents, WriteAtomState as INTERNAL_WriteAtomState, MountDependencies as INTERNAL_MountDependencies, MountAtom as INTERNAL_MountAtom, UnmountAtom as INTERNAL_UnmountAtom, Store as INTERNAL_Store, BuildingBlocks as INTERNAL_BuildingBlocks, StoreHooks as INTERNAL_StoreHooks, };
declare function hasInitialValue<T extends AnyAtom>(atom: T): atom is T & (T extends Atom<infer Value> ? {
    init: Value;
} : never);
type ActuallyWritableAtom<T extends AnyAtom> = T extends WritableAtom<infer V, infer A, infer R> ? T & WritableAtom<V, A, R> : T extends Atom<infer V> ? T & WritableAtom<V, unknown[], unknown> : never;
declare function isActuallyWritableAtom<T extends AnyAtom>(atom: T): atom is ActuallyWritableAtom<T>;
declare function isAtomStateInitialized(atomState: AtomState<AnyValue>): boolean;
declare function returnAtomValue<Value>(atomState: AtomState<Value>): Value;
declare function isPromiseLike(p: unknown): p is PromiseLike<unknown>;
declare function shouldThrowSynchronously(error: unknown): boolean;
declare function addPendingPromiseToDependency(atom: AnyAtom, promise: PromiseLike<AnyValue>, dependencyAtomState: AtomState): void;
declare function getMountedOrPendingDependents(atom: AnyAtom, atomState: AtomState, mountedMap: MountedMap): Iterable<AnyAtom>;
type StoreHook = {
    (): void;
    add(callback: () => void): () => void;
};
type StoreHookForAtoms = {
    (atom: AnyAtom): void;
    add(atom: AnyAtom, callback: () => void): () => void;
    add(atom: undefined, callback: (atom: AnyAtom) => void): () => void;
};
/** StoreHooks are an experimental API. */
type StoreHooks = {
    /** Listener to notify when the atom state is created. */
    readonly i?: StoreHookForAtoms;
    /** Listener to notify when the atom is read. */
    readonly r?: StoreHookForAtoms;
    /** Listener to notify when the atom value is changed. */
    readonly c?: StoreHookForAtoms;
    /** Listener to notify when the atom is mounted. */
    readonly m?: StoreHookForAtoms;
    /** Listener to notify when the atom is unmounted. */
    readonly u?: StoreHookForAtoms;
    /** Listener to notify when callbacks are being flushed. */
    readonly f?: StoreHook;
};
declare function initializeStoreHooks(storeHooks: StoreHooks): Required<StoreHooks>;
declare function getBuildingBlocks(store: Store): Readonly<BuildingBlocks>;
declare function buildStore(partialBuildingBlocks?: Partial<BuildingBlocks>): Store;
export { buildStore as INTERNAL_buildStoreRev4, getBuildingBlocks as INTERNAL_getBuildingBlocksRev4, initializeStoreHooks as INTERNAL_initializeStoreHooksRev4, KEY_atomStateMap as INTERNAL_KEY_atomStateMap, KEY_mountedMap as INTERNAL_KEY_mountedMap, KEY_invalidatedAtoms as INTERNAL_KEY_invalidatedAtoms, KEY_changedAtoms as INTERNAL_KEY_changedAtoms, KEY_mountCallbacks as INTERNAL_KEY_mountCallbacks, KEY_unmountCallbacks as INTERNAL_KEY_unmountCallbacks, KEY_storeHooks as INTERNAL_KEY_storeHooks, KEY_atomRead as INTERNAL_KEY_atomRead, KEY_atomWrite as INTERNAL_KEY_atomWrite, KEY_atomOnInit as INTERNAL_KEY_atomOnInit, KEY_atomOnMount as INTERNAL_KEY_atomOnMount, KEY_ensureAtomState as INTERNAL_KEY_ensureAtomState, KEY_flushCallbacks as INTERNAL_KEY_flushCallbacks, KEY_recomputeInvalidatedAtoms as INTERNAL_KEY_recomputeInvalidatedAtoms, KEY_readAtomState as INTERNAL_KEY_readAtomState, KEY_invalidateDependents as INTERNAL_KEY_invalidateDependents, KEY_writeAtomState as INTERNAL_KEY_writeAtomState, KEY_mountDependencies as INTERNAL_KEY_mountDependencies, KEY_mountAtom as INTERNAL_KEY_mountAtom, KEY_unmountAtom as INTERNAL_KEY_unmountAtom, KEY_setAtomStateValueOrPromise as INTERNAL_KEY_setAtomStateValueOrPromise, KEY_storeGet as INTERNAL_KEY_storeGet, KEY_storeSet as INTERNAL_KEY_storeSet, KEY_storeSub as INTERNAL_KEY_storeSub, KEY_enhanceBuildingBlocks as INTERNAL_KEY_enhanceBuildingBlocks, KEY_abortHandlersMap as INTERNAL_KEY_abortHandlersMap, KEY_registerAbortHandler as INTERNAL_KEY_registerAbortHandler, KEY_abortPromise as INTERNAL_KEY_abortPromise, KEY_storeEpochHolder as INTERNAL_KEY_storeEpochHolder, hasInitialValue as INTERNAL_hasInitialValue, isActuallyWritableAtom as INTERNAL_isActuallyWritableAtom, isAtomStateInitialized as INTERNAL_isAtomStateInitialized, returnAtomValue as INTERNAL_returnAtomValue, isPromiseLike as INTERNAL_isPromiseLike, shouldThrowSynchronously as INTERNAL_shouldThrowSynchronously, addPendingPromiseToDependency as INTERNAL_addPendingPromiseToDependency, getMountedOrPendingDependents as INTERNAL_getMountedOrPendingDependents, };

export { atom } from './vanilla/atom.js';
export type { Atom, WritableAtom, PrimitiveAtom } from './vanilla/atom.js';
export { createStore, getDefaultStore, INTERNAL_overrideCreateStore, } from './vanilla/store.js';
export type { Getter, Setter, ExtractAtomValue, ExtractAtomArgs, ExtractAtomResult, SetStateAction, } from './vanilla/typeUtils.js';

export { useResetAtom } from './utils/useResetAtom.js';
export { useReducerAtom } from './utils/useReducerAtom.js';
export { useAtomCallback } from './utils/useAtomCallback.js';
export { useHydrateAtoms } from './utils/useHydrateAtoms.js';

export { Provider, useStore } from './react/Provider.js';
export { useAtomValue } from './react/useAtomValue.js';
export { useAtomValueRaw } from './react/useAtomValueRaw.js';
export { useAtomValueRawSync } from './react/useAtomValueRawSync.js';
export { useSetAtom } from './react/useSetAtom.js';
export { useAtom } from './react/useAtom.js';

export { RESET } from './utils/constants.js';
export { atomWithReset } from './utils/atomWithReset.js';
export { atomWithReducer } from './utils/atomWithReducer.js';
export { selectAtom } from './utils/selectAtom.js';
export { freezeAtom, freezeAtomCreator } from './utils/freezeAtom.js';
export { splitAtom } from './utils/splitAtom.js';
export { atomWithDefault } from './utils/atomWithDefault.js';
export { atomWithStorage, createJSONStorage, withStorageValidator as unstable_withStorageValidator, } from './utils/atomWithStorage.js';
export { atomWithObservable } from './utils/atomWithObservable.js';
export { unwrap } from './utils/unwrap.js';
export { atomWithRefresh } from './utils/atomWithRefresh.js';
export { atomWithLazy } from './utils/atomWithLazy.js';