import { AsJSON, ConstructorOf, Ctor, EnvironmentData, Fn, RootStore, Store, Transceiver } from "atom.io/internal";
import { stringified } from "atom.io/foundations/json";
import { UList } from "atom.io/transceivers/u-list";
import { Loadable as Loadable$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, ReadonlyPureSelectorToken as ReadonlyPureSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, RegularAtomToken as RegularAtomToken$1, ViewOf as ViewOf$1, WritableFamilyToken as WritableFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, WritableToken as WritableToken$1, findState as findState$1 } from "atom.io";
import { Junction, JunctionEntriesBase, JunctionSchemaBase, Refinement as Refinement$1 } from "atom.io/foundations/junction";
import { Canonical } from "atom.io/foundations/canonical";
import { DeepReadonly, Flat, ViewOf } from "atom.io/foundations/type-utils";
//#region src/main/timeline.d.ts
type TimelineManageable = AtomFamilyToken<any, any, any> | AtomToken<any, any, any>;
type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any, any, any> : M extends AtomToken<any, any, any> ? M : never;
type TimelineInspection = {
  at: number;
  length: number;
};
/** A deeply readonly logical update that is about to settle in a timeline. */
type TimelineRecordEvent<ManagedAtom extends TimelineManageable = TimelineManageable> = {
  readonly type: `timeline_record`;
  readonly event: DeepReadonly<TimelineEvent<ManagedAtom>>;
};
/** Safe history-collection tools supplied to a {@link TimelineEffect}. */
type TimelineEffectors<ManagedAtom extends TimelineManageable = TimelineManageable> = {
  /** Observe complete logical updates before they settle in the timeline. */
  onRecord: (callback: (event: TimelineRecordEvent<ManagedAtom>) => void) => void;
  /** Retain at most this many complete undo steps. */
  cullUndoSteps: (limit: number) => void;
  /** The token of the timeline. */
  token: TimelineToken<ManagedAtom>;
  /** The store in which the timeline exists. */
  store: Store;
};
/** A lifecycle hook that observes and safely collects timeline history. */
type TimelineEffect<ManagedAtom extends TimelineManageable = TimelineManageable> = (tools: TimelineEffectors<ManagedAtom>) => void | (() => void);
/**
 * Describes how one atom family is divided among the members of a timeline family.
 *
 * Returning `undefined` from `timelineKey` excludes that atom-family member from
 * every timeline.
 */
type TimelineFamilyScope<TimelineKey extends Canonical, MemberKey extends Canonical = Canonical, ManagedFamily extends AtomFamilyToken<any, MemberKey, any> = AtomFamilyToken<any, MemberKey, any>> = {
  /** The atom family whose members will be routed. */
  family: ManagedFamily;
  /** Selects the timeline key for an atom-family member. */
  timelineKey: (key: MemberKey) => TimelineKey | undefined;
};
/** Options for creating a family of keyed timelines. */
type TimelineFamilyOptions<TimelineKey extends Canonical, Scope extends TimelineFamilyScope<TimelineKey, any, any> = TimelineFamilyScope<TimelineKey, any, any>> = {
  /** The unique identifier of the timeline family. */
  key: string;
  /** Atom families partitioned among the timeline-family members. */
  scope: readonly Scope[];
  /** Creates lifecycle hooks for each timeline-family member. */
  effects?: (key: TimelineKey) => readonly TimelineEffect<Scope[`family`]>[];
};
/**
 * Route an atom family's members into a timeline family.
 *
 * The `timelineKey` function receives each atom-family member's key. It returns
 * the key of the timeline that should record that member, or `undefined` to leave
 * the member untracked.
 *
 * An atom family can belong to only one timeline or timeline family.
 *
 * @param family - The atom family to route.
 * @param options - The function that selects a timeline key for each member.
 * @returns A scope descriptor for {@link timelineFamily}.
 */
declare function scopeFamily<T, MemberKey extends Canonical, E, TimelineKey extends Canonical>(family: AtomFamilyToken<T, MemberKey, E>, options: {
  timelineKey: (key: MemberKey) => TimelineKey | undefined;
}): TimelineFamilyScope<TimelineKey, MemberKey, AtomFamilyToken<T, MemberKey, E>>;
/**
 * Inspect a timeline's current history position.
 * @param timelineToken - A {@link TimelineToken}
 * @overload Timeline
 */
declare function inspectTimeline(timelineToken: TimelineToken<any>): TimelineInspection;
/**
 * Inspect a member of a timeline family, creating it if needed.
 * @param family - A {@link TimelineFamilyToken}.
 * @param key - The key of the timeline-family member.
 * @overload Timeline Family Member
 */
declare function inspectTimeline<K extends Canonical, M extends TimelineManageable>(family: TimelineFamilyToken<K, M>, key: NoInfer<K>): TimelineInspection;
/**
 * If there is an update ahead of the cursor (in the future of this {@link timelineToken}), apply it and move the cursor to the next update
 * @param timelineToken - A {@link TimelineToken}
 * @overload Timeline
 */
declare function redo(timelineToken: TimelineToken<any>): void;
/**
 * Replay the next update in a timeline-family member, creating it if needed.
 * @param family - A {@link TimelineFamilyToken}.
 * @param key - The key of the timeline-family member.
 * @overload Timeline Family Member
 */
declare function redo<K extends Canonical, M extends TimelineManageable>(family: TimelineFamilyToken<K, M>, key: NoInfer<K>): void;
/**
 * Reverse the last update on the {@link timelineToken} and move the cursor to the previous update
 * @param timelineToken - A {@link TimelineToken}
 * @overload Timeline
 */
declare function undo(timelineToken: TimelineToken<any>): void;
/**
 * Reverse the last update in a timeline-family member, creating it if needed.
 * @param family - A {@link TimelineFamilyToken}.
 * @param key - The key of the timeline-family member.
 * @overload Timeline Family Member
 */
declare function undo<K extends Canonical, M extends TimelineManageable>(family: TimelineFamilyToken<K, M>, key: NoInfer<K>): void;
/**
 * Remove all recorded history from the {@link timelineToken} and reset its cursor to the beginning
 * @param timelineToken - A {@link TimelineToken}
 * @overload Timeline
 */
declare function clearTimeline(timelineToken: TimelineToken<any>): void;
/**
 * Remove all history from a timeline-family member, creating it if needed.
 * @param family - A {@link TimelineFamilyToken}.
 * @param key - The key of the timeline-family member.
 * @overload Timeline Family Member
 */
declare function clearTimeline<K extends Canonical, M extends TimelineManageable>(family: TimelineFamilyToken<K, M>, key: NoInfer<K>): void;
/**
 * Permanently dispose of a timeline and its recorded history.
 * @param timelineToken - The timeline to dispose of.
 * @overload Timeline
 */
declare function disposeTimeline(timelineToken: TimelineToken<any>): void;
/**
 * Permanently dispose of a timeline-family member and its recorded history.
 *
 * If the member does not exist, it will not be created.
 *
 * @param family - A {@link TimelineFamilyToken}.
 * @param key - The key of the timeline-family member.
 * @overload Timeline Family Member
 */
declare function disposeTimeline<K extends Canonical, M extends TimelineManageable>(family: TimelineFamilyToken<K, M>, key: NoInfer<K>): void;
type TimelineOptions<ManagedAtom extends TimelineManageable> = {
  /** The unique identifier of the timeline */
  key: string;
  /** The managed atoms (and families of atoms) to record */
  scope: ManagedAtom[];
  /** Hooks that observe and safely collect timeline history. */
  effects?: readonly TimelineEffect<ManagedAtom>[];
};
/**
 * Create a timeline, a mechanism for recording, undoing, and replaying changes to groups of atoms
 * @param options - {@link TimelineOptions}
 * @returns A reference to the timeline created: a {@link TimelineToken}
 */
declare function timeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>): TimelineToken<ManagedAtom>;
/**
 * Create a family of independent timelines, keyed and scoped by atom families.
 *
 * Timeline-family members are created only when they are first used. Existing and
 * future atom-family members are routed to them by the descriptors from
 * {@link scopeFamily}.
 *
 * @param options - {@link TimelineFamilyOptions}
 * @returns A reference to the timeline family created: a {@link TimelineFamilyToken}
 */
declare function timelineFamily<K extends Canonical, Scope extends TimelineFamilyScope<K, any, any> = TimelineFamilyScope<K, any, any>>(options: TimelineFamilyOptions<K, Scope>): TimelineFamilyToken<K, Scope[`family`]>;
/**
 * Find a member of a timeline family, creating it if needed.
 *
 * Repeated calls with the same family and key return the same serializable token.
 *
 * @param family - A {@link TimelineFamilyToken}.
 * @param key - The key of the timeline-family member.
 * @returns A reference to the timeline-family member: a {@link TimelineToken}
 */
declare function findTimeline<K extends Canonical, M extends TimelineManageable>(family: TimelineFamilyToken<K, M>, key: NoInfer<K>): TimelineToken<M, K>;
//#endregion
//#region src/main/tokens.d.ts
/**
 * 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, any> | ReadableToken<any, any, any> | TimelineFamilyToken<any, any> | TimelineToken<any> | TransactionToken<any>;
type ReadableToken<T, K extends Canonical = any, E = never> = AtomToken<T, K, E> | SelectorToken<T, K, E>;
type WritableToken<T, K extends Canonical = any, E = never> = AtomToken<T, K, E> | WritableSelectorToken<T, K, E>;
/**
 * States belonging to this family can be read from the store.
 */
type ReadableFamilyToken<T, K extends Canonical, E = never> = AtomFamilyToken<T, K, E> | SelectorFamilyToken<T, K, E>;
/**
 * States belonging to this family can be written directly.
 */
type WritableFamilyToken<T, K extends Canonical, E = never> = AtomFamilyToken<T, K, E> | WritableSelectorFamilyToken<T, K, E>;
type TimelineToken<M, K extends Canonical = any> = {
  /** The unique identifier of the timeline */
  key: string;
  /** Discriminator */
  type: `timeline`;
  /** Present if the timeline belongs to a family. */
  family?: FamilyMetadata<K>;
  /** Never present. This is a marker that preserves the type of the managed atoms */
  __M?: M;
};
/**
 * A serializable reference to a family of keyed timelines.
 *
 * Use {@link findTimeline} to get a timeline-family member.
 */
type TimelineFamilyToken<K extends Canonical, M = any> = {
  /** The unique identifier of the timeline family */
  key: string;
  /** Discriminator */
  type: `timeline_family`;
  /** Never present. This is a marker that preserves the type of keys used for timelines in this family */
  __K?: K;
  /** Never present. This is a marker that preserves the type of the managed atoms */
  __M?: M;
};
type TransactionToken<F extends Fn> = {
  /** The unique identifier of the transaction */
  key: string;
  /** Discriminator */
  type: `transaction`;
  /** Never present. This is a marker that preserves the type of the transaction function */
  __F?: F;
};
type TokenType<Comparison extends ReadableFamilyToken<any, any, any> | ReadableToken<any, any, any> | TransactionToken<any>> = Comparison extends ReadableToken<infer RepresentedValue, any, infer RepresentedError> ? RepresentedValue | RepresentedError : Comparison extends ReadableFamilyToken<infer RepresentedValue, any, infer RepresentedError> ? RepresentedValue | RepresentedError : Comparison extends TransactionToken<infer TokenFn> ? TokenFn : never;
type AtomToken<T, K extends Canonical = any, E = never> = MutableAtomToken<T extends Transceiver<any, any, any> ? T : never, K> | RegularAtomToken<T, K, E>;
type RegularAtomToken<T, K extends Canonical = any, E = never> = {
  /** 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;
  /** Never present. This is a marker that preserves the type of errors this atom is capable of catching and setting as its value. */
  __E?: E;
};
type MutableAtomToken<T extends Transceiver<any, any, any>, 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?: AsJSON<T>;
};
type SelectorToken<T, K extends Canonical = any, E = never> = ReadonlySelectorToken<T, K, E> | WritableSelectorToken<T, K, E>;
type ReadonlySelectorToken<T, K extends Canonical = any, E = never> = ReadonlyHeldSelectorToken<T, K> | ReadonlyPureSelectorToken<T, K, E>;
type WritableSelectorToken<T, K extends Canonical = any, E = never> = WritableHeldSelectorToken<T, K> | WritablePureSelectorToken<T, K, E>;
type PureSelectorToken<T, K extends Canonical = any, E = never> = ReadonlyPureSelectorToken<T, K, E> | WritablePureSelectorToken<T, K, E>;
type HeldSelectorToken<T, K extends Canonical = any> = ReadonlyHeldSelectorToken<T, K> | WritableHeldSelectorToken<T, K>;
type WritablePureSelectorToken<T, K extends Canonical = any, E = never> = {
  /** The unique identifier of the selector. */
  key: string;
  /** Discriminator. */
  type: `writable_pure_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;
  /** Never present. This is a marker that preserves the type of errors this selector is capable of catching and setting as its value. */
  __E?: E;
};
type WritableHeldSelectorToken<T, K extends Canonical = any> = {
  /** The unique identifier of the selector. */
  key: string;
  /** Discriminator. */
  type: `writable_held_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;
};
type ReadonlyPureSelectorToken<T, K extends Canonical = any, E = never> = {
  /** The unique identifier of the selector. */
  key: string;
  /** Discriminator. */
  type: `readonly_pure_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;
  /** Never present. This is a marker that preserves the type of errors this selector is capable of catching and setting as its value. */
  __E?: E;
};
type ReadonlyHeldSelectorToken<T, K extends Canonical = any> = {
  /** The unique identifier of the selector. */
  key: string;
  /** Discriminator. */
  type: `readonly_held_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;
};
/**
 * 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 AtomFamilyToken<T, K extends Canonical = Canonical, E = never> = MutableAtomFamilyToken<T extends Transceiver<any, any, any> ? T : never, K> | RegularAtomFamilyToken<T, K, E>;
type RegularAtomFamilyToken<T, K extends Canonical, E = never> = {
  /** The unique identifier of the atom family */
  key: string;
  /** Discriminator */
  type: `atom_family`;
  /** Never present. This is a marker that preserves the type of atoms in this family */
  __T?: T;
  /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
  __K?: K;
  /** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
  __E?: E;
};
type MutableAtomFamilyToken<T extends Transceiver<any, any, any>, K extends Canonical> = {
  /** The unique identifier of the atom family */
  key: string;
  /** Discriminator */
  type: `mutable_atom_family`;
  /** Never present. This is a marker that preserves the type of atoms in this family */
  __T?: T;
  /** Never present. This is a marker that preserves the type of keys used for atoms in this family */
  __K?: K;
};
type SelectorFamilyToken<T, K extends Canonical, E = never> = ReadonlySelectorFamilyToken<T, K, E> | WritableSelectorFamilyToken<T, K, E>;
type ReadonlySelectorFamilyToken<T, K extends Canonical, E = never> = ReadonlyHeldSelectorFamilyToken<T, K> | ReadonlyPureSelectorFamilyToken<T, K, E>;
type WritableSelectorFamilyToken<T, K extends Canonical, E = never> = WritableHeldSelectorFamilyToken<T, K> | WritablePureSelectorFamilyToken<T, K, E>;
type PureSelectorFamilyToken<T, K extends Canonical, E = never> = ReadonlyPureSelectorFamilyToken<T, K, E> | WritablePureSelectorFamilyToken<T, K, E>;
type HeldSelectorFamilyToken<T, K extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K> | WritableHeldSelectorFamilyToken<T, K>;
type WritablePureSelectorFamilyToken<T, K extends Canonical, E = never> = {
  /** The unique identifier of the family */
  key: string;
  /** Discriminator */
  type: `writable_pure_selector_family`;
  /** Never present. This is a marker that preserves the type of the value of each family member */
  __T?: T;
  /** Never present. This is a marker that preserves the type of keys used for each family member */
  __K?: K;
  /** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
  __E?: E;
};
type ReadonlyPureSelectorFamilyToken<T, K extends Canonical, E = never> = {
  /** The unique identifier of the family */
  key: string;
  /** Discriminator */
  type: `readonly_pure_selector_family`;
  /** Never present. This is a marker that preserves the type of the value of each family member */
  __T?: T;
  /** Never present. This is a marker that preserves the type of keys used for each family member */
  __K?: K;
  /** Never present. This is a marker that preserves the type of errors this family is capable of catching and setting as its value. */
  __E?: E;
};
type WritableHeldSelectorFamilyToken<T, K extends Canonical> = {
  /** The unique identifier of the family */
  key: string;
  /** Discriminator */
  type: `writable_held_selector_family`;
  /** Never present. This is a marker that preserves the type of the value of each family member */
  __T?: T;
  /** Never present. This is a marker that preserves the type of keys used for each family member */
  __K?: K;
};
type ReadonlyHeldSelectorFamilyToken<T, K extends Canonical> = {
  /** The unique identifier of the family */
  key: string;
  /** Discriminator */
  type: `readonly_held_selector_family`;
  /** Never present. This is a marker that preserves the type of the value of each family member */
  __T?: T;
  /** Never present. This is a marker that preserves the type of keys used for each family member */
  __K?: K;
};
//#endregion
//#region src/main/events.d.ts
type StateUpdate<T> = {
  readonly oldValue?: ViewOf$1<T>;
  readonly newValue: ViewOf$1<T>;
};
type AtomUpdateEvent<A extends AtomToken<any, any, any>> = {
  type: `atom_update`;
  token: A;
  update: StateUpdate<TokenType<A>>;
  timestamp: number;
};
type SelectorUpdateSubEvent<A extends AtomToken<any, any, any>> = AtomUpdateEvent<A> | AtomCreationEvent<any>;
type TimelineSelectorUpdateEvent<A extends TimelineManageable> = {
  type: `selector_update`;
  token: SelectorToken<any>;
  subEvents: SelectorUpdateSubEvent<AtomOnly<A>>[];
  timestamp: number;
};
type AtomCreationEvent<A extends AtomToken<any, any, any>> = {
  type: `atom_creation`;
  token: A;
  timestamp: number;
  value?: TokenType<A>;
};
type AtomDisposalEvent<A extends AtomToken<any, any, any>> = {
  type: `atom_disposal`;
  token: A;
  timestamp: number;
  value?: TokenType<A>;
};
type AtomLifecycleEvent<A extends AtomToken<any, any, any>> = AtomCreationEvent<A> | AtomDisposalEvent<A>;
type MoleculeCreationEvent = {
  type: `molecule_creation`;
  key: Canonical;
  provenance: Canonical;
  timestamp: number;
};
type MoleculeDisposalEvent = {
  type: `molecule_disposal`;
  key: Canonical;
  provenance: stringified<Canonical>[];
  values: [key: string, value: any][];
  timestamp: number;
};
type MoleculeTransferEvent = {
  type: `molecule_transfer`;
  key: Canonical;
  exclusive: boolean;
  from: Canonical[];
  to: Canonical[];
  timestamp: number;
};
type TransactionSubEvent = AtomLifecycleEvent<AtomToken<unknown, any, any>> | AtomUpdateEvent<AtomToken<any, any, any>> | MoleculeCreationEvent | MoleculeDisposalEvent | MoleculeTransferEvent | TransactionOutcomeEvent<TransactionToken<any>>;
type TransactionOutcomeEvent<T extends TransactionToken<any>> = {
  type: `transaction_outcome`;
  token: T;
  id: string;
  timestamp: number;
  subEvents: TransactionSubEvent[];
  params: Parameters<TokenType<T>>;
  output: ReturnType<TokenType<T>>;
};
type TimelineEvent<ManagedAtom extends TimelineManageable> = {
  checkpoint?: true;
} & (AtomUpdateEvent<AtomOnly<ManagedAtom>> | AtomCreationEvent<AtomOnly<ManagedAtom>> | AtomDisposalEvent<AtomOnly<ManagedAtom>> | TimelineSelectorUpdateEvent<ManagedAtom> | TransactionOutcomeEvent<TransactionToken<any>>);
type TimelineCullEvent = {
  type: `timeline_cull`;
  target: `undo_steps`;
  /** Logical undo steps available before collection. */
  from: number;
  /** Logical undo steps remaining after collection. */
  to: number;
};
type TimelineUpdate<ManagedAtom extends TimelineManageable> = {
  type: `timeline_update`;
  event: TimelineEvent<ManagedAtom> | TimelineCullEvent | `clear` | `redo` | `undo`;
  at: number;
  length: number;
};
//#endregion
//#region src/main/atom.d.ts
type RegularAtomOptions<T, E = never> = {
  /** 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?: readonly AtomEffect<T, E>[];
  /** The classes of errors that might be thrown when deriving the atom's default value */
  catch?: readonly Ctor<E>[];
};
/**
 * 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}
 */
declare function atom<T, E = never>(options: RegularAtomOptions<T, E>): RegularAtomToken<T, any, E>;
type MutableAtomOptions<T extends Transceiver<any, any, any>> = {
  /** The unique identifier of the atom */
  key: string;
  /** A constructor for the atom's value */
  class: ConstructorOf<T>;
  /** Hooks used to run side effects when the atom is set */
  effects?: readonly AtomEffect<T>[];
};
/**
 * 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}
 */
declare function mutableAtom<T extends Transceiver<any, any, any>>(options: MutableAtomOptions<T>): MutableAtomToken<T>;
/**
 * 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, E = never> = (tools: Effectors<T, E>) => Loadable$1<(() => void) | void>;
type Effectors<T, E = never> = {
  /**
   * Reset the value of the atom to its default
   */
  resetSelf: () => void;
  /**
   * Set the value of the atom
   * @param next - The new value of the atom, or a setter function
   */
  setSelf: <New extends T>(next: New | ((old: T) => New)) => void;
  /** Subscribe to changes to the atom */
  onSet: (callback: (options: StateUpdate<E | T>) => void) => void;
  /** The token of the atom */
  token: T extends Transceiver<any, any, any> ? MutableAtomToken<T> : AtomToken<T, any, E>;
  /** The store in which the atom exists */
  store: Store;
};
type RegularAtomFamilyOptions<T, K extends Canonical, E = never> = {
  /** 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, E>[];
  /** The classes of errors that might be thrown when deriving the atom's default value */
  catch?: readonly Ctor<E>[];
};
/**
 * Create a family of regular atoms, allowing for the dynamic creation and disposal of atoms.
 * @param options - {@link RegularAtomFamilyOptions}
 * @returns
 * A reference to the atom family created: a {@link RegularAtomFamilyToken}
 */
declare function atomFamily<T, K extends Canonical, E = never>(options: RegularAtomFamilyOptions<T, K, E>): RegularAtomFamilyToken<T, K, E>;
type MutableAtomFamilyOptions<T extends Transceiver<any, any, any>, K extends Canonical> = {
  /** The unique identifier of the atom family */
  key: string;
  /** The class of the transceiver to be created */
  class: ConstructorOf<T>;
  /** Hooks used to run side effects when an atom in the family is set  */
  effects?: (key: K) => AtomEffect<T>[];
};
/**
 * Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
 *
 * The value of a mutable atom must be some kind of {@link Transceiver}.
 *
 * @param options - {@link MutableAtomFamilyOptions}
 * @returns
 * A reference to the atom family created: a {@link MutableAtomFamilyToken}
 */
declare function mutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical>(options: MutableAtomFamilyOptions<T, K>): MutableAtomFamilyToken<T, K>;
//#endregion
//#region src/main/dispose-state.d.ts
/**
 * Disposes of a state in the implicit store.
 *
 * Only family members can be disposed of.
 *
 * @param token - The token of the state to dispose
 * @overload Default
 */
declare function disposeState(token: ReadableToken<any, any>): void;
/**
 * Disposes of a state in the implicit store.
 *
 * Only family members can be disposed of.
 *
 * @param token - The token of the state family to dispose
 * @param key - The unique key of the state to dispose
 * @overload Streamlined
 */
declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K, any>, key: K): void;
//#endregion
//#region src/main/find-state.d.ts
/**
 * Finds a {@link MutableAtomToken} in the store, without accessing its value.
 *
 * In an ephemeral store, this will create a new atom if one does not exist with the given key.
 *
 * In an immortal store, a "counterfeit" atom token will be returned in this case and a warning will be logged.
 *
 * @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, any, any>, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken$1<T, K>;
/**
 * Finds a {@link RegularAtomToken} in the store, without accessing its value.
 *
 * In an ephemeral store, this will create a new atom if one does not exist with the given key.
 *
 * In an immortal store, a "counterfeit" atom token will be returned in this case and a warning will be logged.
 *
 * @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<T, K>, key: Key): RegularAtomToken$1<T, Key>;
/**
 * Finds a {@link WritableSelectorToken} in the store, without accessing its value.
 *
 * In an ephemeral store, this will create a new selector if one does not exist with the given key.
 *
 * In an immortal store, a "counterfeit" selector token will be returned in this case and a warning will be logged.
 *
 * @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, Key>;
/**
 * Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
 *
 * In an ephemeral store, this will create a new selector if one does not exist with the given key.
 *
 * In an immortal store, a "counterfeit" selector token will be returned in this case and a warning will be logged.
 *
 * @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, Key>;
/**
 * Finds a {@link WritableToken} in the store, without accessing its value.
 *
 * In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
 *
 * In an immortal store, a "counterfeit" token will be returned in this case and a warning will be logged.
 *
 * @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, Key>;
/**
 * Finds a {@link MutableAtomToken} in the store, without accessing its value.
 *
 * In an ephemeral store, this will create a new atom or selector if one does not exist with the given key.
 *
 * In an immortal store, a "counterfeit" token will be returned in this case and a warning will be logged.
 *
 * @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, Key>;
//#endregion
//#region src/main/get-json-token.d.ts
/**
 * Get the JSON form of a mutable atom as a writable state token.
 * @param token - A {@link MutableAtomToken}
 * @returns A token representing the mutable atom's JSON form
 * @overload Mutable Atom
 */
declare function getJsonToken<T extends Transceiver<any, any, any>, K extends Canonical>(token: MutableAtomToken<T, K>): WritablePureSelectorToken<AsJSON<T>, K>;
/**
 * Get the JSON form of a mutable atom family member as a writable state token.
 * @param token - A {@link MutableAtomFamilyToken}
 * @param key - The key of the family member
 * @returns A token representing the mutable atom family member's JSON form
 * @overload Mutable Atom Family
 */
declare function getJsonToken<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, K>, key: NoInfer<Key>): WritablePureSelectorToken<AsJSON<T>, Key>;
//#endregion
//#region src/main/get-state.d.ts
/**
 * Read or compute 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, E = never>(token: ReadableToken<T, any, E>): ViewOf$1<E | T>;
/**
 * Read or compute the current value of a state
 * @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, E = never>(token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>): ViewOf$1<E | T>;
//#endregion
//#region src/main/join.d.ts
type JoinOptions<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = Flat<JunctionSchemaBase<AName, BName> & {
  /** Unique identifier of the join */
  readonly key: string;
  /** How many relations are allowed in each direction? */
  readonly cardinality: Cardinality;
  /** Type guard for the type of the left side */
  readonly isAType: Refinement$1<string, A>;
  /** Type guard for the type of the right side */
  readonly isBType: Refinement$1<string, B>;
}> & Partial<JunctionEntriesBase<A, B, null>>;
type JoinToken<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = {
  /** Unique identifier of the join */
  key: string;
  /** Discriminator */
  type: `join`;
  /** How many relations are allowed in each direction? */
  cardinality: Cardinality;
  /** Name of the join's left side */
  a: AName;
  /** Name of the join's right side */
  b: BName;
  /** Never present. This is a marker that preserves the type of the left side's keys */
  __aType?: A;
  /** Never present. This is a marker that preserves the type of the right side's keys */
  __bType?: B;
};
/**
 * Create a join, an interface for managing relations between two sets of keys.
 *
 * Use joins when it is important to view relationships from either side.
 *
 * Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
 *
 * @param options - {@link JoinOptions}
 * @returns
 * A reference to the join created: a {@link JoinToken}
 */
declare function join<const AName extends string, const A extends string, const BName extends string, const B extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<AName, A, BName, B, Cardinality>): JoinToken<AName, A, BName, B, Cardinality>;
type JoinStates<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`> = Cardinality extends `1:1` ? { readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A | null, B>; } & { readonly [N in BName as `${N}KeyOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B | null, A>; } : Cardinality extends `1:n` ? { readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A | null, B>; } & { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B[], A>; } : Cardinality extends `n:n` ? { readonly [N in AName as `${N}KeysOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken$1<A[], B>; } & { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken$1<B[], A>; } : never;
/**
 * Find the current value of a relation owned by a {@link join}
 * @param token - The token of the join
 * @param key - The key of the relation to find
 * @returns
 * A {@link JoinStates} interface to access the relation
 * @overload Default
 */
declare function findRelations<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A, BName, B, Cardinality>, key: A | B): JoinStates<AName, A, BName, B, Cardinality>;
/**
 * Change one or multiple relations owned by a {@link join}
 * @param token - The token of the join
 * @param change - A function that takes a {@link Junction} interface to edit the relations
 */
declare function editRelations<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(token: JoinToken<AName, A, BName, B, Cardinality>, change: (relations: Junction<AName, A, BName, B>) => void): void;
/**
 * @param token - The token of the join
 * @returns
 * A {@link MutableAtomFamilyToken} to access the internal relations
 */
declare function getInternalRelations<A extends string, B extends string>(token: JoinToken<any, A, any, B, any>): MutableAtomFamilyToken$1<UList<A> | UList<B>, A | B>;
declare function getInternalRelations<A extends string, B extends string>(token: JoinToken<any, A, any, B, any>, split: `split`): [atob: MutableAtomFamilyToken$1<UList<B>, A>, btoa: MutableAtomFamilyToken$1<UList<A>, B>];
//#endregion
//#region src/main/logger.d.ts
declare const LOGGER_ICON_DICTIONARY: {
  readonly "🔨": "Create state";
  readonly "🛠️": "Install state into store";
  readonly "👪": "Family member added";
  readonly "🔥": "Family member deleted";
  readonly "📃": "Copy mutable";
  readonly "📖": "Read from cache";
  readonly "📝": "Write to cache";
  readonly "❔": "Cache miss";
  readonly "✨": "Value derived";
  readonly "⭐": "Value set";
  readonly "⭕": "Operation start";
  readonly "🔴": "Operation complete";
  readonly "🚫": "Operation blocked";
  readonly "🟢": "Operation unblocked";
  readonly "🗑": "Evict cached value";
  readonly "🧹": "Prepare to evict";
  readonly "🧮": "Computing selector";
  readonly "🔌": "Register direct dependency";
  readonly "🔍": "Discover root";
  readonly "📁": "Stow update";
  readonly "🛫": "Begin transaction";
  readonly "🛄": "Apply transaction";
  readonly "🛬": "Complete transaction";
  readonly "💥": "Transaction caught error";
  readonly "🪂": "Abort transaction";
  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 "🧼": "Timeline cleared";
  readonly "💣": "Dangerous action likely to cause bad errors down the line";
  readonly "❗": "Dangerous action unless in development mode";
  readonly "❌": "Conflict prevents attempted action";
  readonly "🐞": "Possible bug in AtomIO";
  readonly "💁": "Advice and guidance to the developer";
  readonly "👀": "Subscription added";
  readonly "🙈": "Subscription canceled";
  readonly "📢": "Notify subscribers";
  readonly "🛰️": "Server socket";
  readonly "📡": "Client socket";
  readonly "👍": "Successful operation";
};
type LoggerIcon = keyof typeof LOGGER_ICON_DICTIONARY;
type EntityDenomination = `atom_family` | `atom` | `key` | `mutable_atom_family` | `mutable_atom` | `readonly_held_selector_family` | `readonly_held_selector` | `readonly_pure_selector_family` | `readonly_pure_selector` | `socket` | `state` | `timeline` | `timeline_family` | `transaction` | `unknown` | `user` | `writable_held_selector_family` | `writable_held_selector` | `writable_pure_selector_family` | `writable_pure_selector`;
declare const PRETTY_ENTITY_NAMES: Record<EntityDenomination, string>;
declare const LOG_LEVELS: readonly ["info", "warn", "error"];
type LogLevel = (typeof LOG_LEVELS)[number];
type LogFn = (icon: LoggerIcon, denomination: EntityDenomination, tokenKey: string, message: string, ...rest: unknown[]) => void;
type LogFilter = (...params: Parameters<LogFn>) => Parameters<LogFn> | boolean;
type Logger = Record<LogLevel, LogFn>;
declare const simpleLog: (logLevel: keyof Logger, prefix?: string) => LogFn;
declare const simpleLogger: Logger;
declare class AtomIOLogger implements Logger {
  logLevel: `error` | `info` | `warn` | null;
  filter: LogFilter | undefined;
  private readonly logger;
  constructor(logLevel: `error` | `info` | `warn` | null, filter?: LogFilter, logger?: Logger);
  error: LogFn;
  info: LogFn;
  warn: LogFn;
}
//#endregion
//#region src/main/not-found-error.d.ts
declare class NotFoundError extends Error {
  constructor(token: AtomIOToken, storeName: string);
}
//#endregion
//#region src/main/reset-state.d.ts
/**
 * Set the value of a state into the implicit store back to its default value.
 * @param token - An atom or writable selector token.
 * @overload Default
 * @default
 */
declare function resetState(token: WritableToken<any, any, any>): void;
/**
 * Set the value of a state into the implicit store back to its default value.
 * @param token - An atom family or writable selector family token.
 * @param key - The unique key of the state to set.
 * @overload Streamlined
 */
declare function resetState<K extends Canonical>(token: WritableFamilyToken<any, K, any>, key: K): void;
//#endregion
//#region src/main/set-state.d.ts
/**
 * 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> = (oldValue: T) => T;
/**
 * 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, TT extends T>(token: WritableToken<T, any, any>, value: Setter<TT> | TT): void;
/**
 * 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, TT extends T, K extends Canonical>(token: WritableFamilyToken<T, K, any>, key: NoInfer<K>, value: Setter<TT> | TT): void;
//#endregion
//#region src/main/transaction.d.ts
type ReaderToolkit = Pick<ActorToolkit, `find` | `get` | `json`> & {
  relations: Pick<RelationsToolkit, `find` | `internal`>;
};
type WriterToolkit = Pick<ActorToolkit, `find` | `get` | `json` | `relations` | `set`>;
type ActorToolkit = Readonly<{
  get: typeof getState;
  set: typeof setState;
  reset: typeof resetState;
  find: typeof findState;
  json: <T extends Transceiver<any, any, any>>(state: MutableAtomToken<T>) => WritablePureSelectorToken<AsJSON<T>>;
  dispose: typeof disposeState;
  run: typeof runTransaction;
  env: () => EnvironmentData;
  relations: RelationsToolkit;
}>;
type RelationsToolkit = {
  edit: typeof editRelations;
  find: typeof findRelations;
  internal: typeof getInternalRelations;
};
type Read<F extends Fn> = (toolkit: ReaderToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
type Write<F extends Fn> = (toolkit: WriterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
type Transact<F extends Fn> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer F> ? F : never;
type TransactionOptions<F extends Fn> = {
  /** The unique identifier of the transaction */
  key: string;
  /** The operation to perform */
  do: Transact<F>;
};
/**
 * Create a transaction, a mechanism for batching updates multiple states in a single, all-or-nothing operation
 * @param options - {@link TransactionOptions}
 * @returns A reference to the transaction created: a {@link TransactionToken}
 */
declare function transaction<F extends Fn>(options: TransactionOptions<F>): TransactionToken<F>;
/**
 * Execute a {@link transaction}
 * @param token - A {@link TransactionToken}
 * @param id - A unique identifier for the transaction. If not provided, a random identifier will be generated
 * @returns A function that can be called to run the transaction with its {@link TransactionIO} parameters
 */
declare function runTransaction<F extends Fn>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
/**
 * Undo a transaction on every timeline where it is the current head.
 *
 * Timelines that have moved elsewhere are left unchanged. If `id` is omitted,
 * the most recent eligible instance is used.
 *
 * @param token - The transaction to undo.
 * @param id - The optional identifier of a specific transaction instance.
 */
declare function undoTransaction<F extends Fn>(token: TransactionToken<F>, id?: string): void;
/**
 * Redo a transaction on every timeline where it is the next head.
 *
 * Timelines that have moved elsewhere are left unchanged. If `id` is omitted,
 * the oldest eligible instance is used.
 *
 * @param token - The transaction to redo.
 * @param id - The optional identifier of a specific transaction instance.
 */
declare function redoTransaction<F extends Fn>(token: TransactionToken<F>, id?: string): void;
//#endregion
//#region src/main/selector.d.ts
type WritablePureSelectorOptions<T, E = never> = {
  /** The unique identifier of the selector */
  key: string;
  /** For each instantiated selector, a function that computes its value */
  get: Read<() => T>;
  /** For each instantiated selector, a function that sets its value */
  set: Write<(newValue: T) => void>;
  /** The classes of errors that might be thrown when deriving the atom's default value */
  catch?: readonly Ctor<E>[];
};
type ReadonlyPureSelectorOptions<T, E = never> = {
  /** The unique identifier of the selector */
  key: string;
  /** For each instantiated selector, a function that computes its value */
  get: Read<() => T>;
  /** The classes of errors that might be thrown when deriving the atom's default value */
  catch?: readonly Ctor<E>[];
};
type ReadonlyHeldSelectorOptions<T extends object> = {
  /** The unique identifier of the selector */
  key: string;
  /** For each instantiated selector, a constant reference to a value that will not be replaced */
  const: T;
  /** For each instantiated selector, a function that computes its value */
  get: Read<(permanent: T) => void>;
};
type WritableHeldSelectorOptions<T extends object> = {
  /** The unique identifier of the selector */
  key: string;
  /** For each instantiated selector, a constant reference to a value that will not be replaced */
  const: T;
  /** For each instantiated selector, a function that computes its value */
  get: Read<(permanent: T) => void>;
  /** For each instantiated selector, a function that sets its value */
  set: Write<(newValue: T) => void>;
};
/**
 * Declare a selector. The value of a selector should depend
 * on the value of atoms or other selectors in the store, and
 * should be recycled when a root atom of the selector is set.
 *
 * A held selector's value must be some object.
 * The reference to that object is permanent and will not be replaced.
 *
 * A writable selector can be "set" to a new value.
 * It is strongly advised to set its dependencies to values
 * that would produce the new value of the selector.
 *
 * @param options - {@link WritableHeldSelectorOptions}.
 * @returns
 * The token for your selector.
 * @overload WritableHeld
 */
declare function selector<T extends object>(options: WritableHeldSelectorOptions<T>): WritableHeldSelectorToken<T>;
/**
 * Declare a selector. The value of a selector should depend
 * on the value of atoms or other selectors in the store,
 * and should be recycled when a root atom of the selector is set.
 *
 * A held selector's value must be some object.
 * The reference to that object is permanent and will not be replaced.
 *
 * A readonly selector can be "gotten" but not "set".
 *
 * @param options - {@link ReadonlyHeldSelectorOptions}.
 * @returns
 * The token for your selector.
 * @overload ReadonlyHeld
 */
declare function selector<T extends object>(options: ReadonlyHeldSelectorOptions<T>): ReadonlyHeldSelectorToken<T>;
/**
 * Declare a selector. The value of a selector should depend
 * on the value of atoms or other selectors in the store.
 *
 * A pure selector's current value is evicted from the store
 * in order to be garbage collected when a root atom of the selector is set.
 *
 * A writable selector can be "set" to a new value.
 * It is strongly advised to set its dependencies to values
 * that would produce the new value of the selector.
 *
 * @param options - {@link TransientWritableSelectorOptions}.
 * @returns
 * The token for your selector.
 * @overload WritablePure
 */
declare function selector<T, E = never>(options: WritablePureSelectorOptions<T, E>): WritablePureSelectorToken<T, any, E>;
/**
 * Declare a selector. The value of a selector should depend
 * on the value of atoms or other selectors in the store.
 *
 * A pure selector's current value is evicted from the store
 * in order to be garbage collected when a root atom of the selector is set.
 *
 * A readonly selector can be "gotten" but not "set".
 *
 * @param options - {@link ReadonlyPureSelectorOptions}.
 * @returns
 * The token for your selector.
 * @overload ReadonlyPure
 */
declare function selector<T, E = never>(options: ReadonlyPureSelectorOptions<T, E>): ReadonlyPureSelectorToken<T, any, E>;
type WritablePureSelectorFamilyOptions<T, K extends Canonical, E = never> = {
  /** The unique identifier of the family */
  key: string;
  /** For each instantiated family member, a function that computes its value */
  get: (key: K) => Read<() => T>;
  /** For each instantiated family member, a function that sets its value */
  set: (key: K) => Write<(newValue: T) => void>;
  /** The classes of errors that might be thrown when deriving the atom's default value */
  catch?: readonly Ctor<E>[];
};
type ReadonlyPureSelectorFamilyOptions<T, K extends Canonical, E = never> = {
  /** The unique identifier of the family */
  key: string;
  /** For each instantiated family member, a function that computes its value */
  get: (key: K) => Read<() => T>;
  /** The classes of errors that might be thrown when deriving the atom's default value */
  catch?: readonly Ctor<E>[];
};
type WritableHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
  /** The unique identifier of the family */
  key: string;
  /** For each instantiated family member, a constant reference to a value that will not be replaced */
  const: (key: K) => T;
  /** For each instantiated family member, a function that computes its value */
  get: (key: K) => Read<(permanent: T) => void>;
  /** For each instantiated family member, a function that sets its value */
  set: (key: K) => Write<(newValue: T) => void>;
};
type ReadonlyHeldSelectorFamilyOptions<T extends object, K extends Canonical> = {
  /** The unique identifier of the family */
  key: string;
  /** For each instantiated family member, a constant reference to a value that will not be replaced */
  const: (key: K) => T;
  /** For each instantiated family member, a function that computes its value */
  get: (key: K) => Read<(permanent: T) => void>;
};
/**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
 * The value of a held selector should depend on the value of atoms or other selectors in the store,
 * and should be recycled when a root atom of the selector is set.
 *
 * A held selector's value must be some object.
 * The reference to that object is permanent and will not be replaced.
 *
 * 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 WritableHeldSelectorFamilyOptions}.
 * @returns
 * A reference to the selector family created: a {@link WritableHeldSelectorFamilyToken}
 * @overload WritableHeld
 */
declare function selectorFamily<T extends object, K extends Canonical>(options: WritableHeldSelectorFamilyOptions<T, K>): WritableHeldSelectorFamilyToken<T, K>;
/**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
 * The value of a held selector should depend on the value of atoms or other selectors in the store,
 * and should be recycled when a root atom of the selector is set.
 *
 * A held selector's value must be some object.
 * The reference to that object is permanent and will not be replaced.
 *
 * A readonly selector can be "gotten" but not "set".
 *
 * @param options - {@link ReadonlyHeldSelectorFamilyOptions}.
 * @returns
 * A reference to the selector family created: a {@link ReadonlyHeldSelectorFamilyToken}
 * @overload ReadonlyHeld
 */
declare function selectorFamily<T extends object, K extends Canonical>(options: ReadonlyHeldSelectorFamilyOptions<T, K>): ReadonlyHeldSelectorFamilyToken<T, K>;
/**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
 * The value of a selector should depend on the value of atoms or other selectors in the store.
 *
 * A pure selector's current value is evicted from the store
 * in order to be garbage collected when a root atom of the selector is set.
 *
 * 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 TransientWritableSelectorFamilyOptions}.
 * @returns
 * A reference to the selector family created: a {@link TransientWritableSelectorFamilyToken}
 * @overload WritablePure
 */
declare function selectorFamily<T, K extends Canonical, E = never>(options: WritablePureSelectorFamilyOptions<T, K, E>): WritablePureSelectorFamilyToken<T, K, E>;
/**
 * Create a family of selectors, allowing for the dynamic creation and disposal of selectors.
 *
 * The value of a selector should depend on the value of atoms or other selectors in the store.
 *
 * A pure selector's current value is evicted from the store
 * in order to be garbage collected when a root atom of the selector is set.
 *
 * A readonly selector can be "gotten" but not "set".
 *
 * @param options - {@link ReadonlyPureSelectorFamilyOptions}.
 * @returns
 * A reference to the selector family created: a {@link ReadonlyPureSelectorFamilyToken}
 * @overload ReadonlyPure
 */
declare function selectorFamily<T, K extends Canonical, E = never>(options: ReadonlyPureSelectorFamilyOptions<T, K, E>): ReadonlyPureSelectorFamilyToken<T, K, E>;
//#endregion
//#region src/main/silo.d.ts
declare class Silo {
  store: RootStore;
  atom: typeof atom;
  mutableAtom: typeof mutableAtom;
  atomFamily: typeof atomFamily;
  mutableAtomFamily: typeof mutableAtomFamily;
  selector: typeof selector;
  selectorFamily: typeof selectorFamily;
  transaction: typeof transaction;
  timeline: typeof timeline;
  /** {@link timelineFamily}, bound to this Silo's store. */
  timelineFamily: typeof timelineFamily;
  findState: typeof findState$1;
  /** {@link findTimeline}, bound to this Silo's store. */
  findTimeline: typeof findTimeline;
  getState: typeof getState;
  setState: typeof setState;
  resetState: typeof resetState;
  disposeState: typeof disposeState;
  subscribe: typeof subscribe;
  undo: typeof undo;
  redo: typeof redo;
  clearTimeline: typeof clearTimeline;
  /** {@link inspectTimeline}, bound to this Silo's store. */
  inspectTimeline: typeof inspectTimeline;
  /** {@link disposeTimeline}, bound to this Silo's store. */
  disposeTimeline: typeof disposeTimeline;
  runTransaction: typeof runTransaction;
  /** {@link undoTransaction}, bound to this Silo's store. */
  undoTransaction: typeof undoTransaction;
  /** {@link redoTransaction}, bound to this Silo's store. */
  redoTransaction: typeof redoTransaction;
  install: (tokens: AtomIOToken[], store?: RootStore) => void;
  constructor(config: Store[`config`], fromStore?: Store | null);
}
//#endregion
//#region src/main/subscribe.d.ts
type UpdateHandler<T> = (update: StateUpdate<T>) => void;
type TransactionUpdateHandler<F extends Fn> = (data: TransactionOutcomeEvent<TransactionToken<F>>) => void;
/**
 * Subscribe to a state in the implicit store
 * @param token - The token of the state to subscribe to
 * @param handleUpdate - A function that will be called when the state is updated
 * @param key - A unique key for the subscription. If not provided, a random key will be generated.
 * @returns A function that can be called to unsubscribe from the state
 * @overload State
 */
declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
/**
 * Subscribe to a transaction in the implicit store
 * @param token - The token of the transaction to subscribe to
 * @param handleUpdate - A function that will be called when the transaction succeeds
 * @param key - A unique key for the subscription. If not provided, a random key will be generated.
 * @returns A function that can be called to unsubscribe from the transaction
 * @overload Transaction
 */
declare function subscribe<F extends Fn>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
/**
 * Subscribe to a timeline in the implicit store
 * @param token - The token of the timeline to subscribe to
 * @param handleUpdate - A function that will be called when a new update is available
 * @param key - A unique key for the subscription. If not provided, a random key will be generated.
 * @returns A function that can be called to unsubscribe from the timeline
 * @overload Timeline
 */
declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M>) => void, key?: string): () => void;
/**
 * Subscribe to a timeline-family member in the implicit store, creating it if needed.
 * @param family - A {@link TimelineFamilyToken}.
 * @param memberKey - The key of the timeline-family member.
 * @param handleUpdate - A function that will be called when a new update is available.
 * @param subscriptionKey - A unique key for the subscription. If not provided, a random key will be generated.
 * @returns A function that can be called to unsubscribe from the timeline-family member.
 * @overload Timeline Family Member
 */
declare function subscribe<K extends Canonical, M extends TimelineManageable>(family: TimelineFamilyToken<K, M>, memberKey: NoInfer<K>, handleUpdate: (update: TimelineUpdate<M>) => void, subscriptionKey?: string): () => void;
//#endregion
//#region src/main/index.d.ts
/**
 * Loadable is used to type atoms or selectors that may at some point be initialized to or set to a {@link Promise}.
 *
 * When a Promise is cached as the value of a state in atom.io, that state will be automatically set to the resolved value of the Promise when it is resolved.
 *
 * As a result, we consider any state that can be a set to a Promise to be a "loadable" state, whose value may or may not be a Promise at any given time.
 */
type Loadable<T> = Promise<T> | T;
//#endregion
export { ActorToolkit, type AtomCreationEvent, type AtomDisposalEvent, AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomIOToken, type AtomLifecycleEvent, AtomOnly, type AtomToken, type AtomUpdateEvent, Effectors, EntityDenomination, type FamilyMetadata, type HeldSelectorFamilyToken, type HeldSelectorToken, JoinOptions, JoinStates, JoinToken, LOG_LEVELS, Loadable, LogFilter, LogFn, LogLevel, Logger, LoggerIcon, type MoleculeCreationEvent, type MoleculeDisposalEvent, type MoleculeTransferEvent, MutableAtomFamilyOptions, type MutableAtomFamilyToken, MutableAtomOptions, type MutableAtomToken, NotFoundError, PRETTY_ENTITY_NAMES, type PureSelectorFamilyToken, type PureSelectorToken, Read, type ReadableFamilyToken, type ReadableToken, ReaderToolkit, ReadonlyHeldSelectorFamilyOptions, type ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, type ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, type ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, type ReadonlyPureSelectorToken, type ReadonlySelectorFamilyToken, type ReadonlySelectorToken, RegularAtomFamilyOptions, type RegularAtomFamilyToken, RegularAtomOptions, type RegularAtomToken, RelationsToolkit, type SelectorFamilyToken, type SelectorToken, type SelectorUpdateSubEvent, Setter, Silo, type StateUpdate, type TimelineCullEvent, TimelineEffect, TimelineEffectors, type TimelineEvent, TimelineFamilyOptions, TimelineFamilyScope, type TimelineFamilyToken, TimelineInspection, TimelineManageable, TimelineOptions, TimelineRecordEvent, type TimelineSelectorUpdateEvent, type TimelineToken, type TimelineUpdate, type TokenType, Transact, TransactionIO, TransactionOptions, type TransactionOutcomeEvent, type TransactionSubEvent, type TransactionToken, TransactionUpdateHandler, UpdateHandler, type ViewOf, type WritableFamilyToken, WritableHeldSelectorFamilyOptions, type WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, type WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, type WritablePureSelectorFamilyToken, WritablePureSelectorOptions, type WritablePureSelectorToken, type WritableSelectorFamilyToken, type WritableSelectorToken, type WritableToken, Write, WriterToolkit, atom, atomFamily, clearTimeline, disposeState, disposeTimeline, editRelations, findRelations, findState, findTimeline, getInternalRelations, getJsonToken, getState, inspectTimeline, join, mutableAtom, mutableAtomFamily, redo, redoTransaction, resetState, runTransaction, scopeFamily, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, timelineFamily, transaction, undo, undoTransaction };
//# sourceMappingURL=index.d.ts.map