atom.io 0.4.1 → 0.6.0

package/dist/index.d.ts

@@ -1,6 +1,13 @@
 import * as Rx from 'rxjs';
 import { Hamt } from 'hamt_plus';
-import { Refinement } from 'fp-ts/Refinement';
+import { Refinement } from 'fp-ts/lib/Refinement';
+
+type ƒn = (...parameters: any[]) => any;
+
+type JsonInterface<T, J extends Json = Json> = {
+    toJson: (t: T) => J;
+    fromJson: (json: J) => T;
+};
 
 type Primitive = boolean | number | string | null;
 type Serializable = Primitive | Readonly<{
@@ -23,6 +30,11 @@ type RelationData<CONTENT extends JsonObj | null = null, A extends string = `fro
     a: A;
     b: B;
 };
+type IsRelationDataOptions<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
+    from?: A;
+    to?: B;
+    isContent?: (json: Json) => json is CONTENT;
+};
 
 type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
 type NullSafeRest<MaybeArg> = MaybeArg extends null ? [] | [undefined] : [MaybeArg];
@@ -35,9 +47,11 @@ declare class Join<CONTENT extends JsonObj | null = null, A extends string = `fr
     readonly contents: Record<string, CONTENT>;
     constructor(json?: Partial<RelationData<CONTENT, A, B>>);
     toJSON(): RelationData<CONTENT, A, B>;
-    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, isContent?: Refinement<unknown, CONTENT>, a?: A, b?: B): Join<CONTENT, A, B>;
+    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, options?: IsRelationDataOptions<CONTENT, A, B>): Join<CONTENT, A, B>;
     from<AA extends string>(newA: AA): Join<CONTENT, AA, B>;
     to<BB extends string>(newB: BB): Join<CONTENT, A, BB>;
+    makeJsonInterface: (...params: CONTENT extends null ? [
+    ] : [Refinement<unknown, CONTENT>]) => JsonInterface<Join<CONTENT, A, B>, RelationData<CONTENT, A, B>>;
     getRelatedId(id: string): string | undefined;
     getRelatedIds(id: string): string[];
     getContent(idA: string, idB: string): CONTENT | undefined;
@@ -66,9 +80,8 @@ interface Store {
         source: string;
     }>;
     selectors: Hamt<Selector<any>, string>;
-    timelines: Hamt<Timeline, string>;
     timelineAtoms: Join<null, `timelineKey`, `atomKey`>;
-    timelineStore: Hamt<TimelineData, string>;
+    timelines: Hamt<Timeline, string>;
     transactions: Hamt<Transaction<any>, string>;
     valueMap: Hamt<any, string>;
     subject: {
@@ -85,7 +98,7 @@ interface Store {
         logger__INTERNAL: Logger;
     };
 }
-declare const createStore: (name: string) => Store;
+declare const createStore: (name: string, store?: Store | null) => Store;
 declare const IMPLICIT: {
     STORE_INTERNAL: Store | undefined;
     readonly STORE: Store;
@@ -131,18 +144,19 @@ type Atom<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 readonlySelectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<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> | ReadonlySelectorToken<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: ReadonlySelectorToken<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: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T>;
+declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | null;
+declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | null;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | null;
+declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | null;
 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>;
@@ -210,32 +224,11 @@ 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: ReadonlySelectorToken<S> | StateToken<S>) => S;
-    set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
-};
-type ReadonlyTransactors = Pick<Transactors, `get`>;
-type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-type TransactionOptions<ƒ extends ƒn> = {
-    key: string;
-    do: Write<ƒ>;
-};
-type Transaction<ƒ extends ƒn> = {
-    key: string;
-    type: `transaction`;
-    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-    subject: Rx.Subject<TransactionUpdate<ƒ>>;
-};
-type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer ƒ> ? ƒ : never;
-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;
+    install: (store: Store) => void;
     subject: Rx.Subject<{
         newValue: T;
         oldValue: T;
@@ -247,19 +240,50 @@ type ReadonlySelector<T> = {
     key: string;
     type: `readonly_selector`;
     family?: FamilyMetadata;
+    install: (store: Store) => void;
     subject: Rx.Subject<{
         newValue: T;
         oldValue: T;
     }>;
     get: () => T;
 };
+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): ReadonlySelectorToken<T>;
+
 declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>)[];
+
+type TransactionToken<_> = {
+    key: string;
+    type: `transaction`;
+    __brand?: _;
+};
+type TransactionUpdate<ƒ extends ƒn> = {
+    key: string;
+    atomUpdates: KeyedStateUpdate<unknown>[];
+    params: Parameters<ƒ>;
+    output: ReturnType<ƒ>;
+};
+type Transactors = {
+    get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S;
+    set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
+};
+type ReadonlyTransactors = Pick<Transactors, `get`>;
+type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type TransactionOptions<ƒ extends ƒn> = {
+    key: string;
+    do: Write<ƒ>;
+};
+type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer ƒ> ? ƒ : never;
+declare function transaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>): TransactionToken<ƒ>;
+declare const runTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, store?: Store) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+
+declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
+
 declare const traceSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => AtomToken<unknown>[];
 declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomToken<unknown>[];
+
 declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<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): ReadonlySelectorToken<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;
@@ -276,62 +300,68 @@ declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>
 declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
 declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
 
-type Timeline = {
+type TimelineAtomUpdate = StateUpdate<unknown> & {
     key: string;
-    type: `timeline`;
-    next: () => void;
-    prev: () => void;
-};
-type TimelineAtomUpdate = KeyedStateUpdate<unknown> & {
     type: `atom_update`;
+    timestamp: number;
 };
 type TimelineSelectorUpdate = {
     key: string;
     type: `selector_update`;
-    atomUpdates: TimelineAtomUpdate[];
+    timestamp: number;
+    atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
 };
 type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+    key: string;
     type: `transaction_update`;
+    timestamp: number;
 };
-type TimelineData = {
+type Timeline = {
+    key: string;
     at: number;
     timeTraveling: boolean;
-    history: (TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate)[];
+    history: TimelineUpdate[];
     selectorTime: number | null;
     transactionKey: string | null;
+    install: (store: Store) => void;
+    subject: Rx.Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate>;
 };
-declare function timeline__INTERNAL(options: TimelineOptions, store?: Store): TimelineToken;
+declare function timeline__INTERNAL(options: TimelineOptions, store?: Store, data?: Timeline | null): TimelineToken;
 
-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> = {
+type Transaction<ƒ extends ƒn> = {
     key: string;
-    atomUpdates: KeyedStateUpdate<unknown>[];
-    params: Parameters<ƒ>;
-    output: ReturnType<ƒ>;
+    type: `transaction`;
+    install: (store: Store) => void;
+    subject: Rx.Subject<TransactionUpdate<ƒ>>;
+    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
 };
+declare function transaction__INTERNAL<ƒ extends ƒn>(options: TransactionOptions<ƒ>, store?: Store): TransactionToken<ƒ>;
+declare const target: (store?: Store) => StoreCore;
+
+declare const abortTransaction: (store: Store) => void;
+
+declare const applyTransaction: <ƒ extends ƒn>(output: ReturnType<ƒ>, store: Store) => void;
+
+declare const buildTransaction: (key: string, params: any[], store: Store) => void;
+
+declare const redoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
+
+declare const undoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
+
+declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
+type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
 type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
     phase: `applying` | `building`;
+    time: number;
     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>;
 type index_OperationProgress = OperationProgress;
 type index_ReadonlySelector<T> = ReadonlySelector<T>;
 type index_Selector<T> = Selector<T>;
@@ -340,13 +370,12 @@ type index_StoreCore = StoreCore;
 declare const index_TRANSACTION_PHASES: typeof TRANSACTION_PHASES;
 type index_Timeline = Timeline;
 type index_TimelineAtomUpdate = TimelineAtomUpdate;
-type index_TimelineData = TimelineData;
 type index_TimelineSelectorUpdate = TimelineSelectorUpdate;
 type index_TimelineTransactionUpdate = TimelineTransactionUpdate;
+type index_Transaction<ƒ extends ƒn> = Transaction<ƒ>;
 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;
@@ -404,7 +433,6 @@ declare namespace index {
   export {
     index_Atom as Atom,
     index_IMPLICIT as IMPLICIT,
-    index_KeyedStateUpdate as KeyedStateUpdate,
     index$1 as META,
     index_OperationProgress as OperationProgress,
     index_ReadonlySelector as ReadonlySelector,
@@ -414,13 +442,12 @@ declare namespace index {
     index_TRANSACTION_PHASES as TRANSACTION_PHASES,
     index_Timeline as Timeline,
     index_TimelineAtomUpdate as TimelineAtomUpdate,
-    index_TimelineData as TimelineData,
     index_TimelineSelectorUpdate as TimelineSelectorUpdate,
     index_TimelineTransactionUpdate as TimelineTransactionUpdate,
+    index_Transaction as Transaction,
     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,
@@ -487,15 +514,21 @@ type SelectorOptions<T> = {
     get: Read<() => T>;
     set: Write<(newValue: T) => void>;
 };
-type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>;
-declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
+type ReadonlySelectorOptions<T> = {
+    key: string;
+    get: Read<() => T>;
+};
 declare function selector<T>(options: SelectorOptions<T>): SelectorToken<T>;
+declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 type SelectorFamilyOptions<T, K extends Serializable> = {
     key: string;
     get: (key: K) => Read<() => T>;
     set: (key: K) => Write<(newValue: T) => void>;
 };
-type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<SelectorFamilyOptions<T, K>, `set`>;
+type ReadonlySelectorFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    get: (key: K) => Read<() => T>;
+};
 type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
     key: string;
     type: `selector_family`;
@@ -509,14 +542,34 @@ type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K
 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 Silo = ReturnType<typeof silo>;
+declare const silo: (name: string, fromStore?: Store | null) => {
+    store: Store;
+    atom: typeof atom;
+    atomFamily: typeof atomFamily;
+    selector: typeof selector;
+    selectorFamily: typeof selectorFamily;
+    transaction: typeof transaction;
+    timeline: typeof timeline;
+    getState: typeof getState;
+    setState: typeof setState;
+    subscribe: typeof subscribe;
+    undo: typeof undo;
+    redo: typeof redo;
+};
+
 type StateUpdate<T> = {
     newValue: T;
     oldValue: T;
 };
+type KeyedStateUpdate<T> = StateUpdate<T> & {
+    key: string;
+};
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
 declare const subscribe: <T>(token: ReadonlySelectorToken<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);
+declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update: TimelineUpdate) => void, store?: Store) => (() => void);
 
 type TimelineToken = {
     key: string;
@@ -526,6 +579,7 @@ type TimelineOptions = {
     key: string;
     atoms: (AtomFamily<any> | AtomToken<any>)[];
 };
+type TimelineUpdate = TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate;
 declare const timeline: (options: TimelineOptions) => TimelineToken;
 declare const redo: (token: TimelineToken) => void;
 declare const undo: (token: TimelineToken) => void;
@@ -534,28 +588,27 @@ type AtomToken<_> = {
     key: string;
     type: `atom`;
     family?: FamilyMetadata;
+    __brand?: _;
 };
 type SelectorToken<_> = {
     key: string;
     type: `selector`;
     family?: FamilyMetadata;
+    __brand?: _;
 };
 type StateToken<T> = AtomToken<T> | SelectorToken<T>;
 type ReadonlySelectorToken<_> = {
     key: string;
     type: `readonly_selector`;
     family?: FamilyMetadata;
+    __brand?: _;
 };
 type FamilyMetadata = {
     key: string;
     subKey: string;
 };
-type TransactionToken<_> = {
-    key: string;
-    type: `transaction`;
-};
 declare const getState: <T>(token: ReadonlySelectorToken<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: ReadonlySelectorToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
 
-export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };
+export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, KeyedStateUpdate, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, Silo, StateToken, StateUpdate, Store, TimelineOptions, TimelineToken, TimelineUpdate, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, silo, subscribe, subscribeToTimeline, subscribeToTransaction, timeline, transaction, undo, useLogger };