recoil-next 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,573 @@
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+
+/**
+ * TypeScript port of Recoil_Loadable.js
+ */
+declare abstract class BaseLoadable<T> {
+    getValue(): T;
+    toPromise(): Promise<T>;
+    valueMaybe(): T | undefined;
+    valueOrThrow(): T;
+    promiseMaybe(): Promise<T> | undefined;
+    promiseOrThrow(): Promise<T>;
+    errorMaybe(): unknown | undefined;
+    errorOrThrow(): unknown;
+    is(other: Loadable<any>): boolean;
+}
+declare class ValueLoadable<T> extends BaseLoadable<T> {
+    state: 'hasValue';
+    contents: T;
+    constructor(value: T);
+    getValue(): T;
+    toPromise(): Promise<T>;
+    valueMaybe(): T;
+    valueOrThrow(): T;
+    promiseMaybe(): undefined;
+    errorMaybe(): undefined;
+    map<S>(map: (value: T) => Promise<S> | Loadable<S> | S): Loadable<S>;
+}
+declare class ErrorLoadable<T> extends BaseLoadable<T> {
+    state: 'hasError';
+    contents: unknown;
+    constructor(error: unknown);
+    getValue(): T;
+    toPromise(): Promise<T>;
+    valueMaybe(): undefined;
+    promiseMaybe(): undefined;
+    errorMaybe(): unknown;
+    errorOrThrow(): unknown;
+    map<S>(_map: (value: T) => Promise<S> | Loadable<S> | S): Loadable<S>;
+}
+declare class LoadingLoadable<T> extends BaseLoadable<T> {
+    state: 'loading';
+    contents: Promise<T>;
+    constructor(promise: Promise<T>);
+    getValue(): T;
+    toPromise(): Promise<T>;
+    valueMaybe(): undefined;
+    promiseMaybe(): Promise<T>;
+    promiseOrThrow(): Promise<T>;
+    errorMaybe(): undefined;
+    map<S>(map: (value: T) => Promise<S> | Loadable<S> | S): Loadable<S>;
+}
+type Loadable<T> = Readonly<ValueLoadable<T>> | Readonly<ErrorLoadable<T>> | Readonly<LoadingLoadable<T>>;
+declare function loadableAll<Inputs extends ReadonlyArray<Loadable<any> | Promise<any> | any> | Readonly<{
+    [key: string]: Loadable<any> | Promise<any> | any;
+}>>(inputs: Inputs): Loadable<any>;
+declare function isLoadable(x: unknown): x is Loadable<unknown>;
+declare const RecoilLoadable: {
+    of: <T>(value: Promise<T> | Loadable<T> | T) => Loadable<T>;
+    error: <T>(error: unknown) => Readonly<ErrorLoadable<T>>;
+    loading: <T>() => Readonly<LoadingLoadable<T>>;
+    all: typeof loadableAll;
+    isLoadable: typeof isLoadable;
+};
+
+/**
+ * TypeScript port of Recoil_RetentionZone.js
+ */
+declare class RetentionZone {
+}
+declare function retentionZone(): RetentionZone;
+
+/**
+ * TypeScript port of Recoil_RetainedBy.js
+ */
+
+type RetainedBy = 'components' | 'recoilRoot' | RetentionZone | Array<RetentionZone>;
+
+/**
+ * TypeScript port of Recoil_Keys.js
+ */
+type NodeKey = string;
+type StateID = number & {
+    readonly __state: unique symbol;
+};
+type StoreID = number & {
+    readonly __store: unique symbol;
+};
+type ComponentID = number & {
+    readonly __component: unique symbol;
+};
+
+/**
+ * TypeScript port of Recoil_PersistentMap.js
+ */
+interface PersistentMap<K extends string, V> {
+    keys(): Iterable<K>;
+    entries(): Iterable<[K, V]>;
+    get(key: K): V | void;
+    has(key: K): boolean;
+    set(key: K, value: V): PersistentMap<K, V>;
+    delete(key: K): PersistentMap<K, V>;
+    clone(): PersistentMap<K, V>;
+    toMap(): Map<K, V>;
+}
+
+/**
+ * TypeScript port of Recoil_GraphTypes.js
+ */
+
+type Graph = Readonly<{
+    nodeDeps: Map<NodeKey, ReadonlySet<NodeKey>>;
+    nodeToNodeSubscriptions: Map<NodeKey, Set<NodeKey>>;
+}>;
+
+type AtomValues = PersistentMap<NodeKey, Loadable<unknown>>;
+type ComponentCallback = (treeState: TreeState) => void;
+type Retainable$1 = RetentionZone | NodeKey;
+interface TreeState {
+    /**
+     * Version always increments when moving from one state to another, even
+     * if the same state has been seen before.
+     */
+    version: StateID;
+    /**
+     * State ID usually increments, but when going to a snapshot that was
+     * previously rendered the state ID will be re-used.
+     */
+    stateID: StateID;
+    transactionMetadata: Record<string, unknown>;
+    dirtyAtoms: Set<NodeKey>;
+    atomValues: AtomValues;
+    nonvalidatedAtoms: PersistentMap<NodeKey, unknown>;
+}
+interface StoreState {
+    currentTree: TreeState;
+    nextTree: TreeState | null;
+    previousTree: TreeState | null;
+    commitDepth: number;
+    knownAtoms: Set<NodeKey>;
+    knownSelectors: Set<NodeKey>;
+    retention: {
+        referenceCounts: Map<NodeKey | RetentionZone, number>;
+        nodesRetainedByZone: Map<RetentionZone, Set<NodeKey>>;
+        retainablesToCheckForRelease: Set<Retainable$1>;
+    };
+    nodeCleanupFunctions: Map<NodeKey, () => void>;
+    nodeToComponentSubscriptions: Map<NodeKey, Map<ComponentID, [string, ComponentCallback]>>;
+    graphsByVersion: Map<StateID, Graph>;
+    transactionSubscriptions: Map<number, (store: Store) => void>;
+    nodeTransactionSubscriptions: Map<NodeKey, Map<number, (store: Store) => void>>;
+    queuedComponentCallbacks_DEPRECATED: ComponentCallback[];
+    suspendedComponentResolvers: Set<() => void>;
+}
+interface Store {
+    storeID: StoreID;
+    parentStoreID?: StoreID;
+    getState(): StoreState;
+    replaceState(cb: (treeState: TreeState) => TreeState): void;
+    getGraph(version: StateID): Graph;
+    subscribeToTransactions(callback: (store: Store) => void, nodeKey?: NodeKey): {
+        release: () => void;
+    };
+    addTransactionMetadata(metadata: Record<string, unknown>): void;
+    skipCircularDependencyDetection_DANGEROUS?: boolean;
+}
+
+declare class AbstractRecoilValue<T> {
+    readonly key: NodeKey;
+    constructor(key: NodeKey);
+    toJSON(): {
+        key: string;
+    };
+}
+declare class RecoilState<T> extends AbstractRecoilValue<T> {
+}
+declare class RecoilValueReadOnly<T> extends AbstractRecoilValue<T> {
+}
+type RecoilValue<T> = RecoilValueReadOnly<T> | RecoilState<T>;
+declare function isRecoilValue(x: unknown): x is RecoilValue<unknown>;
+
+declare class DefaultValue {
+}
+type PersistenceType = 'url' | 'other' | 'none';
+type PersistenceInfo = {
+    type: PersistenceType;
+    backButton?: boolean;
+};
+type Trigger = 'get' | 'set';
+
+/**
+ * TypeScript port of Recoil_callbackTypes.js
+ */
+
+type ValueOrUpdater<T> = T | DefaultValue | ((prevValue: T) => T | DefaultValue);
+type GetRecoilValue = <T>(recoilValue: RecoilValue<T>) => T;
+type SetRecoilState = <T>(recoilState: RecoilState<T>, valueOrUpdater: ValueOrUpdater<T>) => void;
+type ResetRecoilState = <T>(recoilState: RecoilState<T>) => void;
+
+/**
+ * TypeScript port of Recoil_AtomicUpdates.js
+ */
+
+interface TransactionInterface {
+    get<T>(rv: RecoilValue<T>): T;
+    set<T>(state: RecoilState<T>, valueOrUpdater: ValueOrUpdater<T>): void;
+    reset<T>(state: RecoilState<T>): void;
+}
+
+/**
+ * TypeScript port of Recoil_FunctionalCore.js
+ */
+
+type ComponentInfo = {
+    name: string;
+};
+type RecoilValueInfo<T> = {
+    loadable: Loadable<T> | null;
+    isActive: boolean;
+    isSet: boolean;
+    isModified: boolean;
+    type: 'atom' | 'selector';
+    deps: Iterable<RecoilValue<unknown>>;
+    subscribers: {
+        nodes: Iterable<RecoilValue<unknown>>;
+        components: Iterable<ComponentInfo>;
+    };
+};
+
+/**
+ * Typescript port of Recoil_Snapshot.js
+ */
+
+type SnapshotID = StateID;
+declare class Snapshot {
+    _store: Store;
+    _refCount: number;
+    constructor(storeState: StoreState, parentStoreID?: StoreID);
+    retain(): () => void;
+    /**
+     * Release the snapshot on the next tick.  This means the snapshot is retained
+     * during the execution of the current function using it.
+     */
+    autoRelease_INTERNAL(): void;
+    _release(): void;
+    isRetained(): boolean;
+    checkRefCount_INTERNAL(): void;
+    getStore_INTERNAL(): Store;
+    getID(): SnapshotID;
+    getStoreID(): StoreID;
+    getLoadable: <T>(recoilValue: RecoilValue<T>) => Loadable<T>;
+    getPromise: <T>(recoilValue: RecoilValue<T>) => Promise<T>;
+    getNodes_UNSTABLE: (opt?: {
+        isModified?: boolean;
+        isInitialized?: boolean;
+    }) => Iterable<RecoilValue<any>>;
+    getInfo_UNSTABLE: <T>(recoilValue: RecoilValue<T>) => RecoilValueInfo<T>;
+    map: (mapper: (mutableSnapshot: MutableSnapshot) => void) => Snapshot;
+    asyncMap: (mapper: (mutableSnapshot: MutableSnapshot) => Promise<void>) => Promise<Snapshot>;
+}
+declare function freshSnapshot(initializeState?: (mutableSnapshot: MutableSnapshot) => void): Snapshot;
+declare class MutableSnapshot extends Snapshot {
+    _batch: (fn: () => void) => void;
+    constructor(snapshot: Snapshot, batch: (fn: () => void) => void);
+    set: SetRecoilState;
+    reset: ResetRecoilState;
+    setUnvalidatedAtomValues_DEPRECATED: (values: Map<NodeKey, any>) => void;
+}
+
+/**
+ * TypeScript port of Recoil_Hooks.js
+ */
+
+type SetterOrUpdater<T> = (newValue: T | DefaultValue | ((currVal: T) => T | DefaultValue)) => void;
+type Resetter = () => void;
+declare function useRecoilValueLoadable<T>(recoilValue: RecoilValue<T>): Loadable<T>;
+declare function useRecoilValue<T>(recoilValue: RecoilValue<T>): T;
+declare function useSetRecoilState<T>(recoilState: RecoilState<T>): SetterOrUpdater<T>;
+declare function useResetRecoilState<T>(recoilState: RecoilState<T>): Resetter;
+declare function useRecoilState<T>(recoilState: RecoilState<T>): [T, SetterOrUpdater<T>];
+declare function useRecoilStateLoadable<T>(recoilState: RecoilState<T>): [Loadable<T>, SetterOrUpdater<T>];
+declare function useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE<T>(recoilValue: RecoilValue<T>): Loadable<T>;
+declare function useRecoilValue_TRANSITION_SUPPORT_UNSTABLE<T>(recoilValue: RecoilValue<T>): T;
+declare function useRecoilState_TRANSITION_SUPPORT_UNSTABLE<T>(recoilState: RecoilState<T>): [T, SetterOrUpdater<T>];
+
+/**
+ * TypeScript port of Recoil_useRecoilBridgeAcrossReactRoots
+ */
+
+type RecoilBridge = React.ComponentType<{
+    children: React.ReactNode;
+}>;
+declare function useRecoilBridgeAcrossReactRoots(): RecoilBridge;
+
+/**
+ * TypeScript port of Recoil_useRecoilCallback
+ */
+
+type RecoilCallbackInterface = Readonly<{
+    set: <T>(recoilState: RecoilState<T>, newValue: T | ((currValue: T) => T)) => void;
+    reset: <T>(recoilState: RecoilState<T>) => void;
+    refresh: <T>(recoilValue: RecoilValue<T>) => void;
+    snapshot: Snapshot;
+    gotoSnapshot: (snapshot: Snapshot) => void;
+    transact_UNSTABLE: (transaction: (iface: TransactionInterface) => void) => void;
+}>;
+declare function useRecoilCallback<Args extends ReadonlyArray<unknown>, Return>(fn: (iface: RecoilCallbackInterface) => (...args: Args) => Return, deps?: ReadonlyArray<unknown>): (...args: Args) => Return;
+
+/**
+ * TypeScript port of Recoil_Wrapper.js
+ */
+declare class WrappedValue<T> {
+    value: T;
+    constructor(value: T);
+}
+
+type PersistenceSettings<Stored> = Readonly<PersistenceInfo & {
+    validator: (storedValue: unknown, defaultValue: DefaultValue) => Stored | DefaultValue;
+}>;
+type NewValueOrUpdater<T> = T | DefaultValue | Promise<T | DefaultValue> | WrappedValue<T> | ((currVal: T | DefaultValue) => T | DefaultValue | Promise<T | DefaultValue> | WrappedValue<T>);
+type AtomEffect<T> = (ctx: {
+    node: RecoilState<T>;
+    storeID: StoreID;
+    parentStoreID_UNSTABLE?: StoreID;
+    trigger: Trigger;
+    setSelf: (value: NewValueOrUpdater<T>) => void;
+    resetSelf: () => void;
+    onSet: (handler: (newValue: T, oldValue: T | DefaultValue, isReset: boolean) => void) => void;
+    getPromise: <S>(recoilValue: RecoilValue<S>) => Promise<S>;
+    getLoadable: <S>(recoilValue: RecoilValue<S>) => Loadable<S>;
+    getInfo_UNSTABLE: <S>(recoilValue: RecoilValue<S>) => RecoilValueInfo<S>;
+}) => void | (() => void);
+type AtomOptionsWithoutDefault<T> = Readonly<{
+    key: NodeKey;
+    effects?: ReadonlyArray<AtomEffect<T>>;
+    effects_UNSTABLE?: ReadonlyArray<AtomEffect<T>>;
+    persistence_UNSTABLE?: PersistenceSettings<T>;
+    dangerouslyAllowMutability?: boolean;
+    retainedBy_UNSTABLE?: RetainedBy;
+}>;
+type AtomOptionsWithDefault<T> = Readonly<AtomOptionsWithoutDefault<T> & {
+    default: RecoilValue<T> | Promise<T> | Loadable<T> | WrappedValue<T> | T;
+}>;
+type AtomOptions<T> = AtomOptionsWithDefault<T> | AtomOptionsWithoutDefault<T>;
+declare function atom<T>(options: AtomOptions<T>): RecoilState<T>;
+declare const atomWithWrappedValue: typeof atom & {
+    value: <T>(value: T) => WrappedValue<T>;
+};
+
+/**
+ * TypeScript port of Recoil_CachePolicy.js
+ */
+type EqualityPolicy = 'reference' | 'value';
+type CachePolicy = {
+    eviction: 'lru';
+    maxSize: number;
+    equality?: EqualityPolicy;
+} | {
+    eviction: 'keep-all';
+    equality?: EqualityPolicy;
+} | {
+    eviction: 'most-recent';
+    equality?: EqualityPolicy;
+} | {
+    equality: EqualityPolicy;
+};
+type CachePolicyWithoutEviction = {
+    equality: EqualityPolicy;
+};
+
+/**
+ * TypeScript port of Recoil_selector.js
+ */
+
+type SelectorCallbackInterface<T> = Readonly<RecoilCallbackInterface & {
+    node: RecoilState<T>;
+}>;
+type GetCallback<T> = <Args extends ReadonlyArray<unknown>, Return>(fn: (callbackInterface: SelectorCallbackInterface<T>) => (...args: Args) => Return) => (...args: Args) => Return;
+type BaseSelectorOptions = Readonly<{
+    key: string;
+    dangerouslyAllowMutability?: boolean;
+    retainedBy_UNSTABLE?: RetainedBy;
+    cachePolicy_UNSTABLE?: CachePolicy;
+}>;
+type ReadOnlySelectorOptions<T> = Readonly<BaseSelectorOptions & {
+    get: (opts: {
+        get: GetRecoilValue;
+        getCallback: GetCallback<T>;
+    }) => RecoilValue<T> | Promise<T> | Loadable<T> | WrappedValue<T> | T;
+}>;
+type ReadWriteSelectorOptions<T> = Readonly<ReadOnlySelectorOptions<T> & {
+    set: (opts: {
+        set: SetRecoilState;
+        get: GetRecoilValue;
+        reset: ResetRecoilState;
+    }, newValue: T | DefaultValue) => void;
+}>;
+declare function selector<T>(options: ReadOnlySelectorOptions<T>): RecoilValueReadOnly<T>;
+declare function selector<T>(options: ReadWriteSelectorOptions<T>): RecoilState<T>;
+
+/**
+ * TypeScript port of Recoil_selectorFamily.js
+ */
+
+type Primitive = void | null | boolean | number | string;
+interface HasToJSON {
+    toJSON(): Parameter;
+}
+type Parameter = Primitive | HasToJSON | ReadonlySet<Parameter> | ReadonlyMap<Parameter, Parameter> | ReadonlyArray<Parameter> | {
+    [key: string]: Parameter;
+};
+type BaseSelectorFamilyOptions<P extends Parameter> = Readonly<{
+    key: string;
+    cachePolicyForParams_UNSTABLE?: CachePolicyWithoutEviction;
+    cachePolicy_UNSTABLE?: CachePolicy;
+    dangerouslyAllowMutability?: boolean;
+    retainedBy_UNSTABLE?: RetainedBy | ((param: P) => RetainedBy);
+}>;
+type ReadOnlySelectorFamilyOptions<T, P extends Parameter> = Readonly<BaseSelectorFamilyOptions<P> & {
+    get: (param: P) => (callbacks: {
+        get: GetRecoilValue;
+        getCallback: GetCallback<T>;
+    }) => Promise<T> | Loadable<T> | WrappedValue<T> | RecoilValue<T> | T;
+}>;
+type ReadWriteSelectorFamilyOptions<T, P extends Parameter> = Readonly<ReadOnlySelectorFamilyOptions<T, P> & {
+    set: (param: P) => (callbacks: {
+        set: SetRecoilState;
+        get: GetRecoilValue;
+        reset: ResetRecoilState;
+    }, newValue: T | DefaultValue) => void;
+}>;
+type SelectorFamilyOptions<T, P extends Parameter> = ReadOnlySelectorFamilyOptions<T, P> | ReadWriteSelectorFamilyOptions<T, P>;
+declare function selectorFamily<T, Params extends Parameter>(options: ReadOnlySelectorFamilyOptions<T, Params>): (params: Params) => RecoilValueReadOnly<T>;
+declare function selectorFamily<T, Params extends Parameter>(options: ReadWriteSelectorFamilyOptions<T, Params>): (params: Params) => RecoilState<T>;
+
+/**
+ * TypeScript port of Recoil_RecoilEnv.js
+ */
+type RecoilEnv = {
+    RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED: boolean;
+    RECOIL_GKS_ENABLED: Set<string>;
+};
+declare const env: RecoilEnv;
+
+/**
+ * Typescript port of Recoil_RecoilRoot.js
+ */
+
+type Props = {
+    initializeState_DEPRECATED?: (options: {
+        set: <T>(recoilValue: RecoilValue<T>, value: T) => void;
+        setUnvalidatedAtomValues: (values: Map<string, unknown>) => void;
+    }) => void;
+    initializeState?: (mutableSnapshot: MutableSnapshot) => void;
+    store_INTERNAL?: Store;
+    store?: Store;
+    override?: true;
+    children: ReactNode;
+    skipCircularDependencyDetection_DANGEROUS?: boolean;
+} | {
+    store_INTERNAL?: Store;
+    store?: Store;
+    /**
+     * Defaults to true. If override is true, this RecoilRoot will create a
+     * new Recoil scope. If override is false and this RecoilRoot is nested
+     * within another RecoilRoot, this RecoilRoot will perform no function.
+     * Children of this RecoilRoot will access the Recoil values of the
+     * nearest ancestor RecoilRoot.
+     */
+    override: false;
+    children: ReactNode;
+    skipCircularDependencyDetection_DANGEROUS?: boolean;
+};
+declare function RecoilRoot(props: Props): React__default.ReactElement;
+declare function useRecoilStoreID(): StoreID;
+
+/**
+ * TypeScript port of Recoil_SnapshotHooks
+ */
+
+declare function useRecoilTransactionObserver(callback: (info: {
+    snapshot: Snapshot;
+    previousSnapshot: Snapshot;
+}) => void): void;
+declare function useRecoilSnapshot(): Snapshot;
+declare function useGotoRecoilSnapshot(): (snapshot: Snapshot) => void;
+
+declare function useGetRecoilValueInfo(): (<T>(recoilValue: RecoilValue<T>) => RecoilValueInfo<T>);
+
+declare function useRecoilRefresher<T>(recoilValue: RecoilValue<T>): () => void;
+
+declare function useRecoilTransaction<Args extends ReadonlyArray<unknown>>(fn: (ti: TransactionInterface) => (...args: Args) => void, deps?: ReadonlyArray<unknown>): (...args: Args) => void;
+
+/**
+ * TypeScript port of Recoil_useRetain.js
+ */
+
+type Retainable = RecoilValue<unknown> | RetentionZone;
+declare function useRetain(retainable: Retainable): void;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @oncall recoil
+ */
+
+type AtomFamilyOptionsWithoutDefault<T, P extends Parameter> = Readonly<AtomOptionsWithoutDefault<T> & {
+    effects?: ReadonlyArray<AtomEffect<T>> | ((param: P) => ReadonlyArray<AtomEffect<T>>);
+    retainedBy_UNSTABLE?: RetainedBy | ((param: P) => RetainedBy);
+    cachePolicyForParams_UNSTABLE?: CachePolicyWithoutEviction;
+}>;
+type AtomFamilyOptions<T, P extends Parameter> = (Readonly<AtomFamilyOptionsWithoutDefault<T, P> & {
+    default: RecoilValue<T> | Promise<T> | Loadable<T> | WrappedValue<T> | T | ((param: P) => T | RecoilValue<T> | Promise<T> | Loadable<T> | WrappedValue<T>);
+}>) | AtomFamilyOptionsWithoutDefault<T, P>;
+declare function atomFamily<T, P extends Parameter>(options: AtomFamilyOptions<T, P>): (params: P) => RecoilState<T>;
+
+/**
+ * TypeScript port of Recoil_constSelector.js
+ */
+
+declare function constSelector<T extends Parameter>(constant: T): RecoilValueReadOnly<T>;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @oncall recoil
+ */
+
+declare function errorSelector<T>(message: string): RecoilValueReadOnly<T>;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Wraps another recoil value and prevents writing to it.
+ *
+ * @oncall recoil
+ */
+
+declare function readOnlySelector<T>(atom: RecoilValue<T>): RecoilValueReadOnly<T>;
+
+/**
+ * TypeScript port of Recoil_WaitFor.js
+ */
+
+type RecoilValues = ReadonlyArray<RecoilValueReadOnly<unknown>> | Readonly<{
+    [key: string]: RecoilValueReadOnly<unknown>;
+}>;
+declare const waitForNone: <T extends RecoilValues>(recoilValues: T) => RecoilValueReadOnly<T extends ReadonlyArray<RecoilValueReadOnly<any>> | Readonly<{}> ? {
+    [K in keyof T]: Loadable<T[K] extends RecoilValue<infer V> ? V : never>;
+} : never>;
+declare const waitForAny: <T extends RecoilValues>(recoilValues: T) => RecoilValueReadOnly<T extends ReadonlyArray<RecoilValueReadOnly<any>> | Readonly<{}> ? {
+    [K in keyof T]: Loadable<T[K] extends RecoilValue<infer V> ? V : never>;
+} : never>;
+declare const waitForAll: <T extends RecoilValues>(recoilValues: T) => RecoilValueReadOnly<T extends ReadonlyArray<RecoilValueReadOnly<any>> | Readonly<{}> ? {
+    [K in keyof T]: T[K] extends RecoilValue<infer V> ? V : never;
+} : never>;
+declare const waitForAllSettled: <T extends RecoilValues>(recoilValues: T) => RecoilValueReadOnly<T extends ReadonlyArray<RecoilValueReadOnly<any>> | Readonly<{}> ? {
+    [K in keyof T]: Loadable<T[K] extends RecoilValue<infer V> ? V : never>;
+} : never>;
+declare const noWait: <T>(recoilValue: RecoilValue<T>) => RecoilValueReadOnly<Loadable<T>>;
+
+export { DefaultValue, MutableSnapshot, env as RecoilEnv, RecoilLoadable, RecoilRoot, RecoilState, RecoilValueReadOnly, Snapshot, atomWithWrappedValue as atom, atomFamily, constSelector, errorSelector, isRecoilValue, noWait, readOnlySelector, retentionZone, selector, selectorFamily, freshSnapshot as snapshot_UNSTABLE, useGetRecoilValueInfo as useGetRecoilValueInfo_UNSTABLE, useGotoRecoilSnapshot, useRecoilBridgeAcrossReactRoots as useRecoilBridgeAcrossReactRoots_UNSTABLE, useRecoilCallback, useRecoilRefresher as useRecoilRefresher_UNSTABLE, useRecoilSnapshot, useRecoilState, useRecoilStateLoadable, useRecoilState_TRANSITION_SUPPORT_UNSTABLE, useRecoilStoreID, useRecoilTransactionObserver as useRecoilTransactionObserver_UNSTABLE, useRecoilTransaction as useRecoilTransaction_UNSTABLE, useRecoilValue, useRecoilValueLoadable, useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE, useRecoilValue_TRANSITION_SUPPORT_UNSTABLE, useResetRecoilState, useRetain, useSetRecoilState, waitForAll, waitForAllSettled, waitForAny, waitForNone };
+export type { AtomEffect, GetRecoilValue, Loadable, Parameter, PersistenceSettings, PersistenceType, RecoilBridge, RecoilCallbackInterface, RecoilValue, ResetRecoilState, SelectorFamilyOptions, SetRecoilState, SetterOrUpdater, SnapshotID, StoreID, TransactionInterface };