atom.io 0.32.3 → 0.33.0

package/dist/main/index.d.ts

@@ -0,0 +1,691 @@
+import { Each, EnvironmentData, Flat, Func, Junction, JunctionEntriesBase, JunctionSchemaBase, Refinement, Store, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Transceiver } from "atom.io/internal";
+import { Canonical, Json, JsonInterface, stringified } from "atom.io/json";
+import { MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, WritableToken as WritableToken$1, findState as findState$1, getState as getState$1, setState as setState$1 } from "atom.io";
+import { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx";
+
+//#region src/main/atom.d.ts
+/**
+* @public
+* Create a mutable atom, a global reactive variable in the implicit store
+*
+* The value of a mutable atom must be some kind of {@link Transceiver}.
+*
+* @param options - {@link MutableAtomOptions}.
+* @returns
+* A reference to the atom created: a {@link MutableAtomToken}
+* @overload Mutable
+*/
+/**
+* @public
+* Create a mutable atom, a global reactive variable in the implicit store
+*
+* The value of a mutable atom must be some kind of {@link Transceiver}.
+*
+* @param options - {@link MutableAtomOptions}.
+* @returns
+* A reference to the atom created: a {@link MutableAtomToken}
+* @overload Mutable
+*/
+declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
+/**
+* @public
+* Create a regular atom, a global reactive variable in the implicit store
+* @param options - {@link RegularAtomOptions}.
+* @returns
+* A reference to the atom created: a {@link RegularAtomToken}
+* @overload Regular
+*/
+declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
+/** @public */
+type Effectors<T> = {
+  /**
+  * Set the value of the atom
+  * @param next - The new value of the atom, or a setter function
+  */
+  setSelf: <New extends T>(next: New | Setter<T, New>) => void;
+  /** Subscribe to changes to the atom */
+  onSet: (callback: (options: {
+    newValue: T;
+    oldValue: T;
+  }) => void) => void;
+};
+/**
+* @public
+* A function that runs side effects when the atom is set
+* @param tools - {@link Effectors} that can be used to run side effects
+* @returns
+* Optionally, a cleanup function that will be called when the atom is disposed
+*/
+type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
+/** @public */
+type RegularAtomOptions<T> = {
+  /** The unique identifier of the atom */
+  key: string;
+  /** The starting value of the atom */
+  default: T | (() => T);
+  /** Hooks used to run side effects when the atom is set */
+  effects?: AtomEffect<T>[];
+};
+type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = JsonInterface<T, J> & Omit<RegularAtomOptions<T>, `default`> & {
+  default: () => T;
+  mutable: true;
+};
+/** @public */
+type RegularAtomFamilyOptions<T, K extends Canonical> = {
+  /** The unique identifier of the atom family */
+  key: string;
+  /** The starting value of the atom family */
+  default: T | ((key: K) => T);
+  /** Hooks used to run side effects when an atom in the family is set  */
+  effects?: (key: K) => AtomEffect<T>[];
+};
+type RegularAtomFamilyToken<T, K extends Canonical> = {
+  key: string;
+  type: `atom_family`;
+  __T?: T;
+  __K?: K;
+};
+type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & {
+  key: string;
+  default: (key: K) => T;
+  effects?: (key: K) => AtomEffect<T>[];
+  mutable: true;
+};
+type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
+  key: string;
+  type: `mutable_atom_family`;
+  __T?: T;
+  __J?: J;
+  __K?: K;
+};
+type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
+declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+declare function atomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
+
+//#endregion
+//#region src/main/transaction.d.ts
+type TransactionToken<F extends Func> = {
+  key: string;
+  type: `transaction`;
+  __F?: F;
+};
+type StateCreation<Token extends ReadableToken<any>> = {
+  type: `state_creation`;
+  token: Token;
+};
+type AtomDisposal<Token extends ReadableToken<any>> = {
+  type: `state_disposal`;
+  subType: `atom`;
+  token: Token;
+  value: TokenType<Token>;
+};
+type SelectorDisposal<Token extends ReadableToken<any>> = {
+  type: `state_disposal`;
+  subType: `selector`;
+  token: Token;
+};
+type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
+type MoleculeCreation = {
+  type: `molecule_creation`;
+  key: Canonical;
+  provenance: Canonical;
+};
+type MoleculeDisposal = {
+  type: `molecule_disposal`;
+  key: Canonical;
+  provenance: stringified<Canonical>[];
+  values: [key: string, value: any][];
+};
+type MoleculeTransfer = {
+  type: `molecule_transfer`;
+  key: Canonical;
+  from: Canonical[];
+  to: Canonical[];
+};
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
+type TransactionUpdate<F extends Func> = {
+  type: `transaction_update`;
+  key: string;
+  id: string;
+  epoch: number;
+  updates: TransactionUpdateContent[];
+  params: Parameters<F>;
+  output: ReturnType<F>;
+};
+type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>;
+type SetterToolkit = Readonly<{
+  get: typeof getState$1;
+  set: typeof setState$1;
+  find: typeof findState$1;
+  json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
+}>;
+type ActorToolkit = Readonly<{
+  get: typeof getState$1;
+  set: typeof setState$1;
+  find: typeof findState$1;
+  json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
+  dispose: typeof disposeState;
+  run: typeof runTransaction;
+  env: () => EnvironmentData;
+}>;
+type Read<F extends Func> = (toolkit: GetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Write<F extends Func> = (toolkit: SetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Transact<F extends Func> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type TransactionOptions<F extends Func> = {
+  key: string;
+  do: Transact<F>;
+};
+type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer F> ? F : never;
+declare function transaction<F extends Func>(options: TransactionOptions<F>): TransactionToken<F>;
+declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
+
+//#endregion
+//#region src/main/selector.d.ts
+type WritableSelectorOptions<T> = {
+  key: string;
+  get: Read<() => T>;
+  set: Write<(newValue: T) => void>;
+};
+type ReadonlySelectorOptions<T> = {
+  key: string;
+  get: Read<() => T>;
+};
+/**
+* @public
+* Declare a selector. The value of a selector should depend
+* on the value of atoms or other selectors in the store.
+*
+* A writable selector can be "set" to a new value.
+* It is advised to set its dependencies to values
+* that would produce the new value of the selector.
+* @param options - {@link WritableSelectorOptions}.
+* @returns
+* The token for your selector.
+* @overload Writable
+*/
+declare function selector<T>(options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
+/**
+* @public
+* Declare a selector. The value of a selector should depend
+* on the value of atoms or other selectors in the store.
+* @param options - {@link ReadonlySelectorOptions}.
+*/
+declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
+type WritableSelectorFamilyOptions<T, K extends Canonical> = {
+  key: string;
+  get: (key: K) => Read<() => T>;
+  set: (key: K) => Write<(newValue: T) => void>;
+};
+type ReadonlySelectorFamilyOptions<T, K extends Canonical> = {
+  key: string;
+  get: (key: K) => Read<() => T>;
+};
+type WritableSelectorFamilyToken<T, K extends Canonical> = {
+  key: string;
+  type: `selector_family`;
+  __T?: T;
+  __K?: K;
+};
+type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
+  key: string;
+  type: `readonly_selector_family`;
+  __T?: T;
+  __K?: K;
+};
+type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+declare function selectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
+declare function selectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
+
+//#endregion
+//#region src/main/timeline.d.ts
+type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
+type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
+type TimelineToken<M> = {
+  key: string;
+  type: `timeline`;
+  __M?: M;
+};
+type TimelineOptions<ManagedAtom extends TimelineManageable> = {
+  key: string;
+  scope: ManagedAtom[];
+  shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
+};
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
+declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
+declare const redo: (tl: TimelineToken<any>) => void;
+declare const undo: (tl: TimelineToken<any>) => void;
+
+//#endregion
+//#region src/main/dispose-state.d.ts
+/**
+* @public
+* Disposes of a state in the implicit store
+* @param token - The token of the state to dispose
+* @overload Default
+*/
+declare function disposeState(token: ReadableToken<any>): void;
+/**
+* @public
+* Disposes of a state family in the implicit store
+* @param token - The token of the state family to dispose
+* @param key - The unique key of the state to dispose
+*/
+declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
+
+//#endregion
+//#region src/main/find-state.d.ts
+/**
+* @public
+* Finds a {@link MutableAtomToken} in the store
+* @param token - A {@link MutableAtomFamilyToken}
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Mutable Atom
+*/
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken$1<T, J, K>, key: Key): MutableAtomToken$1<T, J, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Regular Atom
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Writable Selector
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Readonly Selector
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Writable State
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T, K>;
+/**
+* @public
+* Finds a {@link ReadableToken} in the store
+* @param token - A {@link ReadableFamilyToken}
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Unknown
+* @default
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T, K>;
+
+//#endregion
+//#region src/main/get-state.d.ts
+/**
+* @public
+* Get the current value of a state
+* @param token - The token of the state to get
+* @return The current value of the state
+* @overload Default
+* @default
+*/
+declare function getState<T>(token: ReadableToken<T>): T;
+/**
+* @public
+* Get the current value of a state family
+* @param token - The token of a state family
+* @param key - The unique key of the state to get
+* @return The current value of the state
+* @overload Streamlined
+*/
+declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
+
+//#endregion
+//#region src/main/join.d.ts
+interface JoinOptions<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> extends JunctionSchemaBase<ASide, BSide>, Partial<JunctionEntriesBase<AType, BType, Content>> {
+  readonly key: string;
+  readonly cardinality: Cardinality;
+  readonly isAType: Refinement<string, AType>;
+  readonly isBType: Refinement<string, BType>;
+}
+type JoinToken<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
+  key: string;
+  type: `join`;
+  cardinality: Cardinality;
+  a: ASide;
+  b: BSide;
+  __aType?: AType;
+  __bType?: BType;
+  __content?: Content;
+};
+declare function join<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, null>;
+declare function join<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
+type JoinStates<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[BType, Content] | null, AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType | null, BType> } & { readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType | null, AType> } : Cardinality extends `1:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType | null, BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType[], AType> } : Cardinality extends `n:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[AType, Content][], BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType[], BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType[], AType> } : never;
+declare function findRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
+declare function editRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void): void;
+declare function getInternalRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>): MutableAtomFamilyToken$1<SetRTX<string>, SetRTXJson<string>, string>;
+
+//#endregion
+//#region src/main/logger.d.ts
+declare const LoggerIconDictionary: {
+  readonly "⌛": "Timeline event fully captured";
+  readonly "⏩": "Timeline redo";
+  readonly "⏪": "Timeline undo";
+  readonly "⏭️": "Transaction redo";
+  readonly "⏮️": "Transaction undo";
+  readonly "⏳": "Timeline event partially captured";
+  readonly "⏹️": "Time-travel complete";
+  readonly "✅": "Realtime transaction success";
+  readonly "✨": "Computation complete";
+  readonly "❌": "Conflict prevents attempted action";
+  readonly "⭕": "Operation start";
+  readonly "🔴": "Operation complete";
+  readonly "❗": "Operation blocked";
+  readonly "🟢": "Operation unblocked";
+  readonly "🐞": "Possible bug in AtomIO";
+  readonly "👀": "Subscription added";
+  readonly "👋": "Greeting";
+  readonly "👍": "Realtime acknowledgment";
+  readonly "👪": "Family member added";
+  readonly "💁": "Notice";
+  readonly "💥": "Caught";
+  readonly "📁": "Stow update";
+  readonly "📃": "Copy mutable";
+  readonly "📖": "Read state";
+  readonly "📝": "Write state";
+  readonly "📢": "Notify subscribers";
+  readonly "🔄": "Realtime transaction synchronized";
+  readonly "🔌": "Register dependency";
+  readonly "🔍": "Discover root";
+  readonly "🔥": "Delete state";
+  readonly "🔧": "Create mutable atom";
+  readonly "🔨": "Create immutable atom";
+  readonly "🗑": "Evict cached value";
+  readonly "🙈": "Subscription canceled";
+  readonly "🚀": "Performance measure";
+  readonly "🛄": "Apply transaction";
+  readonly "🛠️": "Install atom into store";
+  readonly "🛫": "Begin transaction";
+  readonly "🛬": "Complete transaction";
+  readonly "🧮": "Computing selector";
+  readonly "🧹": "Prepare to evict";
+  readonly "🪂": "Abort transaction";
+  readonly "🤞": "Realtime optimistic update enqueued";
+  readonly "👈": "Realtime confirmed update enqueued";
+  readonly "🧑‍⚖️": "Realtime update beginning reconciliation";
+  readonly "🛎️": "Realtime transaction received";
+  readonly "🔭": "Determining realtime perspective";
+  readonly "🖌": "Redacting realtime update";
+  readonly "👁": "Determining perspective";
+};
+type LoggerIcon = keyof typeof LoggerIconDictionary;
+type TokenDenomination = `atom_family` | `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom_family` | `mutable_atom` | `readonly_selector_family` | `readonly_selector` | `selector_family` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
+declare const LOG_LEVELS: readonly ["info", "warn", "error"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogFn = (icon: LoggerIcon, denomination: TokenDenomination, tokenKey: string, message: string, ...rest: unknown[]) => void;
+type LogFilter = (...params: Parameters<LogFn>) => boolean;
+type Logger = Record<LogLevel, LogFn>;
+declare const simpleLog: (logLevel: keyof Logger) => LogFn;
+declare const simpleLogger: Logger;
+declare class AtomIOLogger implements Logger {
+  logLevel: `error` | `info` | `warn` | null;
+  private readonly filter;
+  private readonly logger;
+  constructor(logLevel: `error` | `info` | `warn` | null, filter?: LogFilter, logger?: Logger);
+  error: LogFn;
+  info: LogFn;
+  warn: LogFn;
+}
+
+//#endregion
+//#region src/main/realm.d.ts
+declare const $claim: unique symbol;
+type Claim<K extends Canonical> = K & {
+  [$claim]?: true;
+};
+declare class Realm<H extends Hierarchy> {
+  store: Store;
+  constructor(store?: Store);
+  allocate<V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V, attachmentStyle?: `all` | `any`): Claim<V>;
+  fuse<C extends CompoundFrom<H>, T extends (C extends CompoundTypedKey<infer t, any, any> ? t : never), A extends (C extends CompoundTypedKey<any, infer v, any> ? v : never), B extends (C extends CompoundTypedKey<any, any, infer m> ? m : never)>(type: T, reagentA: SingularTypedKey<A>, reagentB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+  deallocate<V extends Vassal<H>>(claim: Claim<V>): void;
+  claim<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
+}
+declare class Anarchy {
+  store: Store;
+  realm: Realm<any>;
+  constructor(store?: Store);
+  allocate(provenance: Canonical, key: Canonical, attachmentStyle?: `all` | `any`): void;
+  deallocate(key: Canonical): void;
+  claim(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`): void;
+}
+declare const T$ = "T$";
+type T$ = typeof T$;
+type TypeTag<T extends string> = `${T$}--${T}`;
+type SingularTypedKey<T extends string = string> = `${T}::${string}`;
+type CompoundTypedKey<A extends string = string, B extends string = string, C extends string = string> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`;
+type TypedKey<A extends string = string, B extends string = string, C extends string = string> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>;
+type Scope = SingularTypedKey[];
+type MutualFealty = {
+  above: Scope;
+  below: CompoundTypedKey;
+};
+type ExclusiveFealty = {
+  above: TypedKey | `root`;
+  below: Scope;
+};
+type Fealty = ExclusiveFealty | MutualFealty;
+type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
+type Vassal<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
+  below: Array<infer V>;
+} ? V extends TypedKey ? V : never : never }[keyof H];
+type Above<TK extends TypedKey, H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
+  below: Array<infer V>;
+} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never }[keyof H];
+type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`] ? H[K][`below`] : TK extends H[K][`above`][number] ? H[K][`below`] : never : H[K] extends {
+  above: infer V;
+} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`below`][number] : never : never : never }[keyof H];
+type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`][number] ? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]] : never : never }[keyof H];
+type CompoundFrom<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never }[keyof H];
+
+//#endregion
+//#region src/main/set-state.d.ts
+/**
+* @public
+* A function that sets the value of a state.
+* @param oldValue - The current value of the state.
+* @returns
+* The new value of the state.
+*/
+type Setter<T, New extends T> = (oldValue: T) => New;
+/**
+* @public
+* Set the value of a state into the implicit store.
+* @param token - An atom or writable selector token.
+* @param value - The new value of the state.
+* @overload Default
+* @default
+*/
+declare function setState<T, New extends T>(token: WritableToken<T>, value: New | Setter<T, New>): void;
+/**
+* @public
+* Set the value of a state into the implicit store.
+* @param token - An atom family or writable selector family token.
+* @param key - The unique key of the state to set.
+* @param value - The new value of the state.
+* @overload Streamlined
+*/
+declare function setState<T, K extends Canonical, New extends T, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>): void;
+
+//#endregion
+//#region src/main/silo.d.ts
+declare class Silo {
+  store: Store;
+  atom: typeof atom;
+  atomFamily: typeof atomFamily;
+  selector: typeof selector;
+  selectorFamily: typeof selectorFamily;
+  transaction: typeof transaction;
+  timeline: typeof timeline;
+  findState: typeof findState$1;
+  getState: typeof getState;
+  setState: typeof setState;
+  disposeState: typeof disposeState;
+  subscribe: typeof subscribe;
+  undo: typeof undo;
+  redo: typeof redo;
+  runTransaction: typeof runTransaction;
+  install: (tokens: AtomIOToken[], store?: Store) => void;
+  constructor(config: Store[`config`], fromStore?: Store | null);
+}
+
+//#endregion
+//#region src/main/subscribe.d.ts
+type StateUpdate<T> = {
+  newValue: T;
+  oldValue: T;
+};
+type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
+  key: string;
+  type: `atom_update` | `selector_update`;
+  family?: FamilyMetadata;
+}>;
+type UpdateHandler<T> = (update: StateUpdate<T>) => void;
+type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
+declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
+declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
+
+//#endregion
+//#region src/main/validators.d.ts
+type TokenType<Comparison extends ReadableFamilyToken$1<any, any> | ReadableToken$1<any>> = Comparison extends ReadableToken$1<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken$1<infer RepresentedValue, any> ? RepresentedValue : never;
+declare function isToken<KnownToken extends RegularAtomToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends MutableAtomToken$1<any, any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is MutableAtomToken$1<TokenType<KnownToken>, any>;
+declare function isToken<KnownToken extends WritableSelectorToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is WritableSelectorToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends ReadonlySelectorToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is ReadonlySelectorToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends WritableToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<KnownToken>>;
+declare function isToken<KnownToken extends ReadableToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<KnownToken>>;
+declare function belongsTo<Family extends RegularAtomFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends MutableAtomFamilyToken$1<any, any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is MutableAtomToken$1<TokenType<Family>, any>;
+declare function belongsTo<Family extends WritableSelectorFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableSelectorToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends ReadonlySelectorFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadonlySelectorToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<Family>>;
+declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
+
+//#endregion
+//#region src/main/index.d.ts
+/**
+* @public
+* A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
+*
+* While they represent one of these resources, they are not the resource itself. Think of them like paper currency representing money in the bank.
+*
+* Tokens are returned from resource creation functions, such as {@link atom} and {@link transaction}.
+*
+* Tokens can be used as parameters to functions that take a token, such as {@link getState}, {@link setState}, or {@link runTransaction}.
+*
+* Tokens are fully serializable, so they can be passed between processes.
+*/
+type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
+/** @public */
+type RegularAtomToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the atom. */
+  key: string;
+  /** Discriminator. */
+  type: `atom`;
+  /** Present if the atom belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the atom's value. */
+  __T?: T;
+};
+/** @public */
+type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
+  /** The unique identifier of the atom. */
+  key: string;
+  /** Discriminator. */
+  type: `mutable_atom`;
+  /** Present if the atom belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
+  __J?: J;
+  /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+  __U?: T extends Transceiver<infer Update> ? Update : never;
+};
+/** @public */
+type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+/** @public */
+type WritableSelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+/** @public */
+type ReadonlySelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `readonly_selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+/** @public */
+type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+/**
+* @public
+* These states can be set.
+*/
+type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
+/**
+* @public
+* These states cannot be set.
+*/
+type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
+/**
+* @public
+* States belonging to this family can be set.
+*/
+type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+/**
+* @public
+* States belonging to this family cannot be set.
+*/
+type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+/**
+* @public
+* Identifies a state's connection to its family.
+*/
+type FamilyMetadata<K extends Canonical = any> = {
+  /** The family's unique key. */
+  key: string;
+  /** The family member's unique identifier, in the form of a string. */
+  subKey: stringified<K>;
+};
+type Loadable<T> = Promise<T> | T;
+
+//#endregion
+export { $claim, Above, ActorToolkit, Anarchy, AtomDisposal, AtomEffect, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomOnly, AtomToken, Below, Claim, CompoundFrom, CompoundTypedKey, Effectors, FamilyMetadata, GetterToolkit, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, LOG_LEVELS, Loadable, LogFilter, LogFn, LogLevel, Logger, LoggerIcon, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, Mutuals, Read, ReadableFamilyToken, ReadableToken, ReadonlySelectorFamilyOptions, ReadonlySelectorFamilyToken, ReadonlySelectorOptions, ReadonlySelectorToken, Realm, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorDisposal, SelectorFamilyToken, SelectorToken, Setter, SetterToolkit, Silo, SingularTypedKey, StateCreation, StateDisposal, StateUpdate, T$, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenDenomination, TokenType, Transact, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateContent, TransactionUpdateHandler, TypeTag, TypedKey, UpdateHandler, Vassal, WritableFamilyToken, WritableSelectorFamilyOptions, WritableSelectorFamilyToken, WritableSelectorOptions, WritableSelectorToken, WritableToken, Write, atom, atomFamily, belongsTo, disposeState, editRelations, findRelations, findState, getInternalRelations, getState, isToken, join, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+//# sourceMappingURL=index.d.ts.map