atom.io 0.2.0 → 0.3.0

package/README.md

@@ -3,7 +3,6 @@
 - [x] implicit store
 - [x] readonly selectors
 - [x] settable selectors
-- [x] safe recursive update propagation
 - [x] "tokens" safely expose atoms and selectors
 - [x] give atoms and selectors separate types with a common base
 - [x] utility function to pass logger to your store
@@ -11,25 +10,21 @@
 - [x] atom and selector families
 - [x] atom effects
 - [x] transactions
-
-
-# atom.io
-## upcoming features
-- [x] "lazy mode": only propagate updates downstream to selectors with an active subscription
 - [x] async effects
 - [x] atom default as function
 - [x] check whether an atom is "default" (never set)
+- [x] customizable logging
+
+# atom.io
+## upcoming features
+- [ ] subscribe to token creation
+- [ ] subscribe to transactions
 - [ ] timelines
 - [ ] resettable atoms
 - [ ] resettable selectors
-- [ ] subscribe to transactions
-- [ ] subscribe to token creation
-- [ ] logging levels (debug, info, warn, error)
 - [ ] store observation api
 
 ## fixes & improvements
-- [x] refactor selector dependencies to be asymmetrical
-- [ ] tokens explicitly contain the key of their family
 - [ ] apply and emit transactions all at once
 
 ## documentation

package/dist/index.d.ts

@@ -1,4 +1,505 @@
-export { u as Action, f as AtomEffect, k as AtomFamilyOptions, h as AtomOptions, A as AtomToken, E as Effectors, O as ObserveState, q as ReadonlySelectorFamilyOptions, n as ReadonlySelectorOptions, t as ReadonlyTransactors, R as ReadonlyValueToken, p as SelectorFamilyOptions, m as SelectorOptions, b as SelectorToken, a as StateToken, v as TransactionOptions, T as Transactors, i as __INTERNAL__, j as atom, l as atomFamily, c as configure, g as getState, d as isDefault, o as selector, r as selectorFamily, s as setState, e as subscribe, w as transaction, ƒ as ƒn } from './index-9d9f5a05.js';
-import 'rxjs';
-import 'hamt_plus';
-import 'fp-ts/Refinement';
+import * as Rx from 'rxjs';
+import { Hamt } from 'hamt_plus';
+import { Refinement } from 'fp-ts/Refinement';
+
+type Primitive = boolean | number | string | null;
+type Serializable = Primitive | Readonly<{
+    [key: string]: Serializable;
+}> | ReadonlyArray<Serializable>;
+type JsonObj<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+type JsonArr<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
+type Json = JsonArr | JsonObj | Primitive;
+
+type Identified = {
+    id: string;
+};
+
+declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
+type RelationType = (typeof RELATION_TYPES)[number];
+type RelationData<CONTENT extends JsonObj | null = null> = {
+    contents: JsonObj<string, CONTENT>;
+    relations: JsonObj<string, string[]>;
+    relationType: RelationType;
+};
+
+type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
+type NullSafeRest<MaybeArg> = MaybeArg extends null ? [] | [undefined] : [MaybeArg];
+
+declare class Join<CONTENT extends JsonObj | null = null> implements RelationData<CONTENT> {
+    readonly relationType: `1:1` | `1:n` | `n:n`;
+    readonly relations: Record<string, string[]>;
+    readonly contents: Record<string, CONTENT>;
+    constructor(json?: Partial<RelationData<CONTENT>>);
+    toJSON(): RelationData<CONTENT>;
+    static fromJSON<CONTENT extends JsonObj | null = null>(json: Json, isContent?: Refinement<unknown, CONTENT>): Join<CONTENT>;
+    getRelatedId(id: string): string | undefined;
+    getRelatedIds(id: string): string[];
+    getContent(idA: string, idB: string): CONTENT | undefined;
+    getRelationEntries(id: string): [string, CONTENT][];
+    getRelationRecord(id: string): Record<string, CONTENT>;
+    getRelation(id: string): NullSafeUnion<Identified, CONTENT> | undefined;
+    getRelations(id: string): NullSafeUnion<Identified, CONTENT>[];
+    setRelations(id: string, relations: NullSafeUnion<Identified, CONTENT>[]): Join<CONTENT>;
+    set(idA: string, idB: string, ...rest: NullSafeRest<CONTENT>): Join<CONTENT>;
+    remove(idA: string, idB?: string): Join<CONTENT>;
+}
+
+type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
+interface Store {
+    atoms: Hamt<Atom<any>, string>;
+    atomsThatAreDefault: Set<string>;
+    readonlySelectors: Hamt<ReadonlySelector<any>, string>;
+    selectorAtoms: Join;
+    selectorGraph: Join<{
+        source: string;
+    }>;
+    selectors: Hamt<Selector<any>, string>;
+    timelines: Hamt<Timeline, string>;
+    timelineAtoms: Join;
+    timelineStore: Hamt<TimelineData, string>;
+    transactions: Hamt<Transaction<any>, string>;
+    valueMap: Hamt<any, string>;
+    operation: OperationProgress;
+    transactionStatus: TransactionStatus<ƒn>;
+    config: {
+        name: string;
+        logger: Logger | null;
+        logger__INTERNAL: Logger;
+    };
+}
+declare const createStore: (name: string) => Store;
+declare const IMPLICIT: {
+    STORE_INTERNAL: Store | undefined;
+    readonly STORE: Store;
+};
+declare const clearStore: (store?: Store) => void;
+
+type Effectors<T> = {
+    setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
+    onSet: (callback: (options: {
+        newValue: T;
+        oldValue: T;
+    }) => void) => void;
+};
+type AtomEffect<T> = (tools: Effectors<T>) => void;
+type AtomOptions<T> = {
+    key: string;
+    default: T | (() => T);
+    effects?: AtomEffect<T>[];
+};
+declare function atom<T>(options: AtomOptions<T>): AtomToken<T>;
+type AtomFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    default: T | ((key: K) => T);
+    effects?: (key: K) => AtomEffect<T>[];
+};
+type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
+    key: string;
+    type: `atom_family`;
+    subject: Rx.Subject<AtomToken<T>>;
+};
+declare function atomFamily<T, K extends Serializable>(options: AtomFamilyOptions<T, K>): AtomFamily<T, K>;
+
+type Atom<T> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    subject: Rx.Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    default: T;
+};
+declare function atom__INTERNAL<T>(options: AtomOptions<T>, family?: FamilyMetadata, store?: Store): AtomToken<T>;
+
+declare function atomFamily__INTERNAL<T, K extends Serializable>(options: AtomFamilyOptions<T, K>, store?: Store): AtomFamily<T, K>;
+declare function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
+declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store?: Store): SelectorFamily<T, K>;
+declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
+
+declare const computeSelectorState: <T>(selector: ReadonlySelector<T> | Selector<T>) => T;
+declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown>;
+declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
+declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T>;
+declare function withdraw<T>(token: ReadonlyValueToken<T>, store: Store): ReadonlySelector<T>;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never>;
+declare function withdraw<T>(token: ReadonlyValueToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T>;
+declare function deposit<T>(state: Atom<T>): AtomToken<T>;
+declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
+declare function deposit<T>(state: Atom<T> | Selector<T>): StateToken<T>;
+declare function deposit<T>(state: ReadonlySelector<T>): ReadonlyValueToken<T>;
+declare function deposit<T>(state: Transaction<T extends ƒn ? T : never>): TransactionToken<T>;
+declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlyValueToken<T> | StateToken<T>;
+declare const getState__INTERNAL: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
+
+declare const isAtomDefault: (key: string, store?: Store) => boolean;
+declare const markAtomAsDefault: (key: string, store?: Store) => void;
+declare const markAtomAsNotDefault: (key: string, store?: Store) => void;
+declare const isSelectorDefault: (key: string, store?: Store) => boolean;
+
+type Logger = Pick<Console, `error` | `info` | `warn`>;
+declare const LOG_LEVELS: ReadonlyArray<keyof Logger>;
+declare const setLogLevel: (preferredLevel: `error` | `info` | `warn` | null, store?: Store) => void;
+declare const useLogger: (logger: Logger, store?: Store) => void;
+
+type OperationProgress = {
+    open: false;
+} | {
+    open: true;
+    done: Set<string>;
+    prev: Hamt<any, string>;
+};
+declare const openOperation: (store: Store) => void;
+declare const closeOperation: (store: Store) => void;
+declare const isDone: (key: string, store?: Store) => boolean;
+declare const markDone: (key: string, store?: Store) => void;
+declare const recallState: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
+declare const cacheValue: (key: string, value: unknown, store?: Store) => void;
+declare const evictCachedValue: (key: string, store?: Store) => void;
+declare const readCachedValue: <T>(key: string, store?: Store) => T;
+declare const isValueCached: (key: string, store?: Store) => boolean;
+declare const storeAtom: (atom: Atom<any>, store?: Store) => void;
+declare const storeSelector: (selector: Selector<any>, store?: Store) => void;
+declare const storeReadonlySelector: (selector: ReadonlySelector<any>, store?: Store) => void;
+declare const hasKeyBeenUsed: (key: string, store?: Store) => boolean;
+
+type ƒn = (...parameters: any[]) => any;
+type Transactors = {
+    get: <S>(state: ReadonlyValueToken<S> | StateToken<S>) => S;
+    set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
+};
+type ReadonlyTransactors = Pick<Transactors, `get`>;
+type Action<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type TransactionOptions<ƒ extends ƒn> = {
+    key: string;
+    do: Action<ƒ>;
+};
+type Transaction<ƒ extends ƒn> = {
+    key: string;
+    type: `transaction`;
+    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+    subject: Rx.Subject<TransactionUpdate<ƒ>>;
+};
+declare function transaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>): TransactionToken<ƒ>;
+declare const runTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, store?: Store) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+
+type Selector<T> = {
+    key: string;
+    type: `selector`;
+    family?: FamilyMetadata;
+    subject: Rx.Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    get: () => T;
+    set: (newValue: T | ((oldValue: T) => T)) => void;
+};
+type ReadonlySelector<T> = {
+    key: string;
+    type: `readonly_selector`;
+    family?: FamilyMetadata;
+    subject: Rx.Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    get: () => T;
+};
+declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown>)[];
+declare const traceSelectorAtoms: (selectorKey: string, dependency: ReadonlyValueToken<unknown> | StateToken<unknown>, store: Store) => AtomToken<unknown>[];
+declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomToken<unknown>[];
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlyValueToken<unknown> | StateToken<unknown>, store: Store) => void;
+declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
+declare function selector__INTERNAL<T>(options: SelectorOptions<T>, family?: FamilyMetadata, store?: Store): SelectorToken<T>;
+declare function selector__INTERNAL<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata, store?: Store): ReadonlyValueToken<T>;
+
+declare const evictDownStream: <T>(state: Atom<T>, store?: Store) => void;
+declare const setAtomState: <T>(atom: Atom<T>, next: T | ((oldValue: T) => T), store?: Store) => void;
+declare const setSelectorState: <T>(selector: Selector<T>, next: T | ((oldValue: T) => T), store?: Store) => void;
+declare const setState__INTERNAL: <T>(state: Atom<T> | Selector<T>, value: T | ((oldValue: T) => T), store?: Store) => void;
+
+declare const prepareUpdate: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store: Store) => StateUpdate<T>;
+declare const stowUpdate: <T>(state: Atom<T>, update: StateUpdate<T>, store: Store) => void;
+declare const emitUpdate: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, update: StateUpdate<T>, store: Store) => void;
+declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>, store: Store) => {
+    unsubscribe: () => void;
+}[] | null;
+
+type Timeline = {
+    key: string;
+    type: `timeline`;
+    next: () => void;
+    prev: () => void;
+};
+type TimelineStateUpdate = KeyedStateUpdate<unknown> & {
+    type: `state_update`;
+};
+type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+    type: `transaction_update`;
+};
+type TimelineData = {
+    at: number;
+    timeTraveling: boolean;
+    history: (TimelineStateUpdate | TimelineTransactionUpdate)[];
+};
+declare function timeline__INTERNAL(options: TimelineOptions, store?: Store): TimelineToken;
+declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+
+declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
+type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
+type KeyedStateUpdate<T> = StateUpdate<T> & {
+    key: string;
+};
+type TransactionUpdate<ƒ extends ƒn> = {
+    key: string;
+    atomUpdates: KeyedStateUpdate<unknown>[];
+    params: Parameters<ƒ>;
+    output: ReturnType<ƒ>;
+};
+type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
+    phase: `applying` | `building`;
+    core: StoreCore;
+};
+type TransactionIdle = {
+    phase: `idle`;
+};
+type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
+declare const buildTransaction: (key: string, params: any[], store: Store) => void;
+declare const applyTransaction: <ƒ extends ƒn>(output: ReturnType<ƒ>, store: Store) => void;
+declare const undoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
+declare const redoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
+declare const abortTransaction: (store: Store) => void;
+declare function transaction__INTERNAL<ƒ extends ƒn>(options: TransactionOptions<ƒ>, store?: Store): TransactionToken<ƒ>;
+declare const target: (store?: Store) => StoreCore;
+
+type index_Atom<T> = Atom<T>;
+declare const index_IMPLICIT: typeof IMPLICIT;
+type index_KeyedStateUpdate<T> = KeyedStateUpdate<T>;
+declare const index_LOG_LEVELS: typeof LOG_LEVELS;
+type index_Logger = Logger;
+type index_OperationProgress = OperationProgress;
+type index_ReadonlySelector<T> = ReadonlySelector<T>;
+type index_Selector<T> = Selector<T>;
+type index_Store = Store;
+type index_StoreCore = StoreCore;
+declare const index_TRANSACTION_PHASES: typeof TRANSACTION_PHASES;
+type index_Timeline = Timeline;
+type index_TimelineData = TimelineData;
+type index_TimelineStateUpdate = TimelineStateUpdate;
+type index_TimelineTransactionUpdate = TimelineTransactionUpdate;
+type index_TransactionIdle = TransactionIdle;
+type index_TransactionPhase = TransactionPhase;
+type index_TransactionStatus<ƒ extends ƒn> = TransactionStatus<ƒ>;
+type index_TransactionUpdate<ƒ extends ƒn> = TransactionUpdate<ƒ>;
+type index_TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdateInProgress<ƒ>;
+declare const index_abortTransaction: typeof abortTransaction;
+declare const index_applyTransaction: typeof applyTransaction;
+declare const index_atomFamily__INTERNAL: typeof atomFamily__INTERNAL;
+declare const index_atom__INTERNAL: typeof atom__INTERNAL;
+declare const index_buildTransaction: typeof buildTransaction;
+declare const index_cacheValue: typeof cacheValue;
+declare const index_clearStore: typeof clearStore;
+declare const index_closeOperation: typeof closeOperation;
+declare const index_computeSelectorState: typeof computeSelectorState;
+declare const index_createStore: typeof createStore;
+declare const index_deposit: typeof deposit;
+declare const index_emitUpdate: typeof emitUpdate;
+declare const index_evictCachedValue: typeof evictCachedValue;
+declare const index_evictDownStream: typeof evictDownStream;
+declare const index_getState__INTERNAL: typeof getState__INTERNAL;
+declare const index_hasKeyBeenUsed: typeof hasKeyBeenUsed;
+declare const index_isAtomDefault: typeof isAtomDefault;
+declare const index_isDone: typeof isDone;
+declare const index_isSelectorDefault: typeof isSelectorDefault;
+declare const index_isValueCached: typeof isValueCached;
+declare const index_lookup: typeof lookup;
+declare const index_lookupSelectorSources: typeof lookupSelectorSources;
+declare const index_markAtomAsDefault: typeof markAtomAsDefault;
+declare const index_markAtomAsNotDefault: typeof markAtomAsNotDefault;
+declare const index_markDone: typeof markDone;
+declare const index_openOperation: typeof openOperation;
+declare const index_prepareUpdate: typeof prepareUpdate;
+declare const index_readCachedValue: typeof readCachedValue;
+declare const index_readonlySelectorFamily__INTERNAL: typeof readonlySelectorFamily__INTERNAL;
+declare const index_recallState: typeof recallState;
+declare const index_redoTransactionUpdate: typeof redoTransactionUpdate;
+declare const index_redo__INTERNAL: typeof redo__INTERNAL;
+declare const index_registerSelector: typeof registerSelector;
+declare const index_selectorFamily__INTERNAL: typeof selectorFamily__INTERNAL;
+declare const index_selector__INTERNAL: typeof selector__INTERNAL;
+declare const index_setAtomState: typeof setAtomState;
+declare const index_setLogLevel: typeof setLogLevel;
+declare const index_setSelectorState: typeof setSelectorState;
+declare const index_setState__INTERNAL: typeof setState__INTERNAL;
+declare const index_storeAtom: typeof storeAtom;
+declare const index_storeReadonlySelector: typeof storeReadonlySelector;
+declare const index_storeSelector: typeof storeSelector;
+declare const index_stowUpdate: typeof stowUpdate;
+declare const index_subscribeToRootAtoms: typeof subscribeToRootAtoms;
+declare const index_target: typeof target;
+declare const index_timeline__INTERNAL: typeof timeline__INTERNAL;
+declare const index_traceAllSelectorAtoms: typeof traceAllSelectorAtoms;
+declare const index_traceSelectorAtoms: typeof traceSelectorAtoms;
+declare const index_transaction__INTERNAL: typeof transaction__INTERNAL;
+declare const index_undoTransactionUpdate: typeof undoTransactionUpdate;
+declare const index_undo__INTERNAL: typeof undo__INTERNAL;
+declare const index_updateSelectorAtoms: typeof updateSelectorAtoms;
+declare const index_useLogger: typeof useLogger;
+declare const index_withdraw: typeof withdraw;
+declare namespace index {
+  export {
+    index_Atom as Atom,
+    index_IMPLICIT as IMPLICIT,
+    index_KeyedStateUpdate as KeyedStateUpdate,
+    index_LOG_LEVELS as LOG_LEVELS,
+    index_Logger as Logger,
+    index_OperationProgress as OperationProgress,
+    index_ReadonlySelector as ReadonlySelector,
+    index_Selector as Selector,
+    index_Store as Store,
+    index_StoreCore as StoreCore,
+    index_TRANSACTION_PHASES as TRANSACTION_PHASES,
+    index_Timeline as Timeline,
+    index_TimelineData as TimelineData,
+    index_TimelineStateUpdate as TimelineStateUpdate,
+    index_TimelineTransactionUpdate as TimelineTransactionUpdate,
+    index_TransactionIdle as TransactionIdle,
+    index_TransactionPhase as TransactionPhase,
+    index_TransactionStatus as TransactionStatus,
+    index_TransactionUpdate as TransactionUpdate,
+    index_TransactionUpdateInProgress as TransactionUpdateInProgress,
+    index_abortTransaction as abortTransaction,
+    index_applyTransaction as applyTransaction,
+    index_atomFamily__INTERNAL as atomFamily__INTERNAL,
+    index_atom__INTERNAL as atom__INTERNAL,
+    index_buildTransaction as buildTransaction,
+    index_cacheValue as cacheValue,
+    index_clearStore as clearStore,
+    index_closeOperation as closeOperation,
+    index_computeSelectorState as computeSelectorState,
+    index_createStore as createStore,
+    index_deposit as deposit,
+    index_emitUpdate as emitUpdate,
+    index_evictCachedValue as evictCachedValue,
+    index_evictDownStream as evictDownStream,
+    index_getState__INTERNAL as getState__INTERNAL,
+    index_hasKeyBeenUsed as hasKeyBeenUsed,
+    index_isAtomDefault as isAtomDefault,
+    index_isDone as isDone,
+    index_isSelectorDefault as isSelectorDefault,
+    index_isValueCached as isValueCached,
+    index_lookup as lookup,
+    index_lookupSelectorSources as lookupSelectorSources,
+    index_markAtomAsDefault as markAtomAsDefault,
+    index_markAtomAsNotDefault as markAtomAsNotDefault,
+    index_markDone as markDone,
+    index_openOperation as openOperation,
+    index_prepareUpdate as prepareUpdate,
+    index_readCachedValue as readCachedValue,
+    index_readonlySelectorFamily__INTERNAL as readonlySelectorFamily__INTERNAL,
+    index_recallState as recallState,
+    index_redoTransactionUpdate as redoTransactionUpdate,
+    index_redo__INTERNAL as redo__INTERNAL,
+    index_registerSelector as registerSelector,
+    index_selectorFamily__INTERNAL as selectorFamily__INTERNAL,
+    index_selector__INTERNAL as selector__INTERNAL,
+    index_setAtomState as setAtomState,
+    index_setLogLevel as setLogLevel,
+    index_setSelectorState as setSelectorState,
+    index_setState__INTERNAL as setState__INTERNAL,
+    index_storeAtom as storeAtom,
+    index_storeReadonlySelector as storeReadonlySelector,
+    index_storeSelector as storeSelector,
+    index_stowUpdate as stowUpdate,
+    index_subscribeToRootAtoms as subscribeToRootAtoms,
+    index_target as target,
+    index_timeline__INTERNAL as timeline__INTERNAL,
+    index_traceAllSelectorAtoms as traceAllSelectorAtoms,
+    index_traceSelectorAtoms as traceSelectorAtoms,
+    index_transaction__INTERNAL as transaction__INTERNAL,
+    index_undoTransactionUpdate as undoTransactionUpdate,
+    index_undo__INTERNAL as undo__INTERNAL,
+    index_updateSelectorAtoms as updateSelectorAtoms,
+    index_useLogger as useLogger,
+    index_withdraw as withdraw,
+  };
+}
+
+type SelectorOptions<T> = {
+    key: string;
+    get: (readonlyTransactors: ReadonlyTransactors) => T;
+    set: (transactors: Transactors, newValue: T) => void;
+};
+type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>;
+declare function selector<T>(options: SelectorOptions<T>): SelectorToken<T>;
+declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlyValueToken<T>;
+type SelectorFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    get: (key: K) => (readonlyTransactors: ReadonlyTransactors) => T;
+    set: (key: K) => (transactors: Transactors, newValue: T) => void;
+};
+type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<SelectorFamilyOptions<T, K>, `set`>;
+type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
+    key: string;
+    type: `selector_family`;
+    subject: Rx.Subject<SelectorToken<T>>;
+};
+type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlyValueToken<T>) & {
+    key: string;
+    type: `readonly_selector_family`;
+    subject: Rx.Subject<ReadonlyValueToken<T>>;
+};
+declare function selectorFamily<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>): SelectorFamily<T, K>;
+declare function selectorFamily<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamily<T, K>;
+
+type TimelineToken = {
+    key: string;
+    type: `timeline`;
+};
+type TimelineOptions = {
+    key: string;
+    atoms: (AtomFamily<any> | AtomToken<any>)[];
+};
+declare const timeline: (options: TimelineOptions) => TimelineToken;
+declare const redo: (token: TimelineToken) => void;
+declare const undo: (token: TimelineToken) => void;
+
+type StateUpdate<T> = {
+    newValue: T;
+    oldValue: T;
+};
+type UpdateHandler<T> = (update: StateUpdate<T>) => void;
+declare const subscribe: <T>(token: ReadonlyValueToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, store?: Store) => (() => void);
+type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
+declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, store?: Store) => (() => void);
+
+type AtomToken<_> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+};
+type SelectorToken<_> = {
+    key: string;
+    type: `selector`;
+    family?: FamilyMetadata;
+};
+type StateToken<T> = AtomToken<T> | SelectorToken<T>;
+type ReadonlyValueToken<_> = {
+    key: string;
+    type: `readonly_selector`;
+    family?: FamilyMetadata;
+};
+type FamilyMetadata = {
+    key: string;
+    subKey: string;
+};
+type TransactionToken<_> = {
+    key: string;
+    type: `transaction`;
+};
+declare const getState: <T>(token: ReadonlyValueToken<T> | StateToken<T>, store?: Store) => T;
+declare const setState: <T, New extends T>(token: StateToken<T>, value: New | ((oldValue: T) => New), store?: Store) => void;
+declare const isDefault: (token: ReadonlyValueToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
+
+export { Action, AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlyTransactors, ReadonlyValueToken, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };