import { Json, stringified } from "atom.io/foundations/json";
import { UList } from "atom.io/transceivers/u-list";
import { MapOverlay } from "atom.io/foundations/overlays";
import { StatefulSubject, Subject } from "atom.io/foundations/subject";
import { Future } from "atom.io/foundations/future";
import { ActorToolkit, AtomCreationEvent, AtomDisposalEvent, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomLifecycleEvent, AtomToken, AtomUpdateEvent, FamilyMetadata, HeldSelectorFamilyToken, HeldSelectorToken, JoinOptions, JoinStates, JoinToken, Logger, MoleculeCreationEvent, MoleculeDisposalEvent, MoleculeTransferEvent, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, PureSelectorFamilyToken, PureSelectorToken, ReadableFamilyToken, ReadableToken, ReadonlyHeldSelectorFamilyOptions, ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, ReadonlyPureSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorFamilyToken, SelectorToken, Setter, StateUpdate, TimelineEvent, TimelineFamilyOptions, TimelineFamilyScope, TimelineFamilyToken, TimelineManageable, TimelineOptions, TimelineSelectorUpdateEvent, TimelineToken, TimelineUpdate, TransactionOptions, TransactionOutcomeEvent, TransactionToken, TransactionUpdateHandler, UpdateHandler, ViewOf, WritableFamilyToken, WritableHeldSelectorFamilyOptions, WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, WritablePureSelectorFamilyToken, WritablePureSelectorOptions, WritablePureSelectorToken, WritableSelectorFamilyToken, WritableSelectorToken, WritableToken, WriterToolkit } from "atom.io";
import { Junction } from "atom.io/foundations/junction";
import { Above, CompoundFrom, CompoundTypedKey, Hierarchy, SingularTypedKey, ValidKey, Vassal } from "atom.io/experiments/realms";
import { Canonical } from "atom.io/foundations/canonical";
import { Flat } from "atom.io/foundations/type-utils";
//#region src/internal/arbitrary.d.ts
declare function arbitrary(random?: () => number): string;
//#endregion
//#region src/internal/store/circular-buffer.d.ts
declare class CircularBuffer<T> {
  protected _buffer: T[];
  protected _index: number;
  constructor(array: T[]);
  constructor(length: number);
  get buffer(): ReadonlyArray<T | undefined>;
  get index(): number;
  add(item: T): void;
  copy(): CircularBuffer<T>;
}
//#endregion
//#region src/internal/mutable/transceiver.d.ts
interface Transceiver<V extends {
  subscribe: (key: string, fn: (update: S) => void) => () => void;
}, S extends Json.Serializable, J extends Json.Serializable> {
  READONLY_VIEW: V;
  do: (update: S) => number | `OUT_OF_RANGE` | null;
  undo: (update: S) => void;
  subscribe: (key: string, fn: (update: S) => void) => () => void;
  toJSON: () => J;
}
/**
 * Controls whether a mutable atom may participate in native Atom.io time
 * travel. Append-only transceivers implement history by recording new signals;
 * rewinding their object graph would violate their consistency contract.
 */
type TransceiverTimelinePolicy = `append-only` | `reversible`;
type TransceiverConstructor<J extends Json.Serializable, T extends Transceiver<any, any, J>> = (new () => T) & {
  fromJSON: (json: J) => T;
  readonly timelinePolicy?: TransceiverTimelinePolicy;
};
declare function isTransceiver(value: unknown): value is Transceiver<any, Json.Serializable, Json.Serializable>;
type TransceiverMode = `playback` | `record` | `transaction`;
type SignalFrom<T extends Transceiver<any, any, any>> = T extends Transceiver<any, infer S, any> ? S : never;
type AsJSON<T extends Transceiver<any, any, any>> = T extends Transceiver<any, any, infer J> ? J : never;
type ConstructorOf<T extends Transceiver<any, any, any>> = TransceiverConstructor<AsJSON<T>, T>;
//#endregion
//#region src/internal/mutable/create-mutable-atom.d.ts
declare function createMutableAtom<T extends Transceiver<any, any, any>>(store: Store, options: MutableAtomOptions<T>, family: FamilyMetadata | undefined): MutableAtomToken<T>;
//#endregion
//#region src/internal/utility-types.d.ts
type Fn = (...parameters: any[]) => any;
type Ctor<T> = new (...args: any[]) => T;
type Count<N extends number, A extends any[] = []> = [...A, any][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
type Each<E extends any[]> = { [P in Count<E[`length`]>]: E[P]; };
type Refinement<A, B extends A> = (a: A) => a is B;
//#endregion
//#region src/internal/transaction/transaction-meta-progress.d.ts
declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
type TransactionProgress<F extends Fn> = {
  phase: `applying` | `building`;
  update: TransactionOutcomeEvent<TransactionToken<F>>;
  toolkit: ActorToolkit;
};
type RootTransactionMeta = {
  phase: `idle`;
};
//#endregion
//#region src/internal/transaction/is-root-store.d.ts
interface RootStore extends Store {
  transactionMeta: RootTransactionMeta;
  parent: null;
  child: ChildStore | null;
}
interface ChildStore extends Store {
  transactionMeta: TransactionProgress<Fn>;
  parent: ChildStore | RootStore;
  child: ChildStore | null;
  valueMap: MapOverlay<string, any>;
}
declare function isRootStore(store: Store): store is RootStore;
declare function isChildStore(store: Store): store is ChildStore;
//#endregion
//#region src/internal/transaction/abort-transaction.d.ts
declare function abortTransaction(target: ChildStore): void;
//#endregion
//#region src/internal/transaction/act-upon-store.d.ts
declare function actUponStore<F extends Fn>(store: Store, token: TransactionToken<F>, id: string): (...parameters: Parameters<F>) => ReturnType<F>;
//#endregion
//#region src/internal/transaction/apply-transaction.d.ts
declare function applyTransaction<F extends Fn>(store: ChildStore, output: ReturnType<F>): void;
//#endregion
//#region src/internal/transaction/build-transaction.d.ts
declare function buildTransaction(store: RootStore, token: TransactionToken<any>, params: any[], id: string): ChildStore;
//#endregion
//#region src/internal/transaction/create-transaction.d.ts
type Transaction<F extends Fn> = {
  key: string;
  type: `transaction`;
  install: (store: RootStore) => void;
  subject: Subject<TransactionOutcomeEvent<TransactionToken<F>>>;
  run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
};
declare function createTransaction<F extends Fn>(store: RootStore, options: TransactionOptions<F>): TransactionToken<F>;
//#endregion
//#region src/internal/mutable/create-mutable-atom-family.d.ts
declare function createMutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical>(store: RootStore, options: MutableAtomFamilyOptions<T, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, K>;
//#endregion
//#region src/internal/timeline/clear-timeline.d.ts
declare function clearTimelineInStore(store: Store, token: TimelineToken<any>): void;
//#endregion
//#region src/internal/timeline/create-timeline.d.ts
type TimelineRecordCallback = (event: {
  readonly type: `timeline_record`;
  readonly event: TimelineEvent<any>;
}) => void;
type Timeline<ManagedAtom extends TimelineManageable> = {
  type: `timeline`;
  key: string;
  family?: FamilyMetadata;
  at: number;
  timeTraveling: `into_future` | `into_past` | null;
  history: TimelineEvent<ManagedAtom>[];
  selectorTime: number | null;
  transactionKey: string | null;
  onRecordCallbacks: Set<TimelineRecordCallback>;
  pendingRecord: TimelineEvent<ManagedAtom> | null;
  pendingUndoStepLimit: number | null;
  cleanup: (() => void) | null;
  ownedTopicKeys: Set<string>;
  install: (store: RootStore) => void;
  subject: Subject<TimelineUpdate<ManagedAtom>>;
  subscriptions: Map<string, () => void>;
};
declare function createTimeline<ManagedAtom extends TimelineManageable>(store: RootStore, options: TimelineOptions<ManagedAtom>, data?: Timeline<ManagedAtom>, family?: FamilyMetadata): TimelineToken<ManagedAtom>;
declare function addAtomToTimeline(store: Store, atomToken: AtomToken<any, any, any>, tl: Timeline<any>): void;
declare function handleStateLifecycleEvent(store: Store, event: AtomCreationEvent<any> | AtomDisposalEvent<any>, tl: Timeline<any>): void;
//#endregion
//#region src/internal/timeline/create-timeline-family.d.ts
type TimelineFamily<K extends Canonical, M extends TimelineManageable> = {
  type: `timeline_family`;
  key: string;
  install: (store: RootStore) => void;
  options: TimelineFamilyOptions<K>;
  routes: Map<string, TimelineFamilyScope<K, any, any>>;
  routedAtoms: Map<string, Map<string, AtomToken<any, any, any>>>;
  subscriptions: Map<string, () => void>;
  create: <Key extends K>(key: Key, data?: Timeline<M>) => TimelineToken<M, Key>;
};
declare function createTimelineFamily<K extends Canonical, Scope extends TimelineFamilyScope<K, any, any>>(store: RootStore, options: TimelineFamilyOptions<K, Scope>): TimelineFamilyToken<K, Scope[`family`]>;
declare function createTimelineFamilyMember<K extends Canonical, M extends TimelineManageable, Key extends K>(store: RootStore, familyToken: TimelineFamilyToken<K, M>, key: Key, data?: Timeline<M>): TimelineToken<M, Key>;
declare function seekTimelineInStore<K extends Canonical, M extends TimelineManageable>(store: Store, family: TimelineFamilyToken<K, M>, key: NoInfer<K>): TimelineToken<M, K> | undefined;
declare function findTimelineInStore<K extends Canonical, M extends TimelineManageable>(store: RootStore, familyToken: TimelineFamilyToken<K, M>, key: NoInfer<K>): TimelineToken<M, K>;
//#endregion
//#region src/internal/timeline/dispose-timeline.d.ts
declare function disposeTimelineInStore<M extends TimelineManageable>(store: Store, token: TimelineToken<M>): void;
declare function disposeTimelineInStore<K extends Canonical, M extends TimelineManageable>(store: Store, family: TimelineFamilyToken<K, M>, key: NoInfer<K>): void;
//#endregion
//#region src/internal/timeline/inspect-timeline.d.ts
type TimelineInspection = {
  at: number;
  length: number;
};
declare function inspectTimelineInStore(store: Store, token: TimelineToken<any>): TimelineInspection;
//#endregion
//#region src/internal/timeline/time-travel.d.ts
declare function timeTravel(store: Store, action: `redo` | `undo`, token: TimelineToken<any>): void;
//#endregion
//#region src/internal/timeline/timeline-transaction-group.d.ts
declare const TIMELINE_TRANSACTION_GROUP: unique symbol;
type TimelineTransactionGroup = {
  sequence: number;
  timelineKeys: Set<string>;
};
type GroupedTimelineTransactionEvent = TimelineEvent<any> & TransactionOutcomeEvent<TransactionToken<any>> & {
  [TIMELINE_TRANSACTION_GROUP]: TimelineTransactionGroup;
};
declare function addTimelineToTransactionGroup(outcome: TransactionOutcomeEvent<TransactionToken<any>>, timelineKey: string): TimelineTransactionGroup;
declare function getTimelineTransactionGroup(event: TimelineEvent<any>): TimelineTransactionGroup | undefined;
//#endregion
//#region src/internal/timeline/time-travel-transaction.d.ts
type TransactionTimeTravel = `redo` | `undo`;
declare function timeTravelTransactionInStore(store: Store, action: TransactionTimeTravel, token: TransactionToken<any>, id?: string): void;
declare function timeTravelTransactionGroupInStore(store: Store, action: TransactionTimeTravel, group: TimelineTransactionGroup): boolean;
declare function getTimelineTransactionAtHead(timeline: Timeline<any>, action: TransactionTimeTravel): TimelineTransactionGroup | undefined;
//#endregion
//#region src/internal/state-types.d.ts
type AtomIOState = {
  key: string;
  family?: FamilyMetadata;
  install: (store: RootStore) => void;
  subject: Subject<StateUpdate<any>>;
};
type RegularAtom<T, E> = Flat<AtomIOState & {
  type: `atom`;
  default: T | (() => T);
  cleanup?: () => void;
  internalRoles?: InternalRole[];
  catch?: readonly Ctor<E>[];
  __T?: T;
  __E?: E;
}>;
type MutableAtom<T extends Transceiver<any, any, any>> = Flat<AtomIOState & {
  type: `mutable_atom`;
  class: ConstructorOf<T>;
  cleanup?: () => void;
  __T?: T;
}>;
type Atom<T, E> = RegularAtom<T, E> | (T extends Transceiver<any, any, any> ? MutableAtom<T> : never);
type WritableHeldSelector<T> = Flat<AtomIOState & {
  type: `writable_held_selector`;
  const: T;
  getFrom: (target: Store) => T;
  setSelf: (newValue: T) => void;
  __T?: T;
}>;
type ReadonlyHeldSelector<T> = Flat<AtomIOState & {
  type: `readonly_held_selector`;
  const: T;
  getFrom: (target: Store) => T;
  __T?: T;
}>;
type WritablePureSelector<T, E> = Flat<AtomIOState & {
  type: `writable_pure_selector`;
  getFrom: (target: Store) => E | T;
  setSelf: (newValue: T) => void;
  catch?: readonly Ctor<E>[];
  __T?: T;
  __E?: E;
}>;
type ReadonlyPureSelector<T, E> = Flat<AtomIOState & {
  type: `readonly_pure_selector`;
  getFrom: (target: Store) => E | T;
  catch?: readonly Ctor<E>[];
  __T?: T;
  __E?: E;
}>;
type ReadonlySelector<T, E> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T, E>;
type WritableSelector<T, E> = WritableHeldSelector<T> | WritablePureSelector<T, E>;
type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>;
type PureSelector<T, E> = ReadonlyPureSelector<T, E> | WritablePureSelector<T, E>;
type Selector<T, E> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T, E> | WritableHeldSelector<T> | WritablePureSelector<T, E>;
type WritableState<T, E> = Atom<T, E> | WritableSelector<T, E>;
type ReadableState<T, E> = Atom<T, E> | Selector<T, E>;
type RegularAtomFamily<T, K extends Canonical, E = never> = Flat<RegularAtomFamilyToken<T, K, E> & {
  create: <Key extends K>(key: Key) => RegularAtomToken<T, Key, E>;
  default: T | ((key: K) => T);
  install: (store: RootStore) => void;
  internalRoles: string[] | undefined;
  subject: Subject<AtomLifecycleEvent<RegularAtomToken<T, K, E>>>;
}>;
type MutableAtomFamily<T extends Transceiver<any, any, any>, K extends Canonical> = Flat<MutableAtomFamilyToken<T, K> & {
  create: <Key extends K>(key: Key) => MutableAtomToken<T, Key>;
  class: ConstructorOf<T>;
  install: (store: RootStore) => void;
  internalRoles: string[] | undefined;
  subject: Subject<AtomLifecycleEvent<MutableAtomToken<T, K>>>;
}>;
type AtomFamily<T, K extends Canonical, E> = MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K> | RegularAtomFamily<T, K, E>;
type WritablePureSelectorFamily<T, K extends Canonical, E> = Flat<WritablePureSelectorFamilyToken<T, K, E> & {
  create: <Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>;
  default: (key: K) => T;
  install: (store: RootStore) => void;
  internalRoles: string[] | undefined;
}>;
type WritableHeldSelectorFamily<T, K extends Canonical> = Flat<WritableHeldSelectorFamilyToken<T, K> & {
  create: <Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>;
  default: (key: K) => T;
  install: (store: RootStore) => void;
  internalRoles: string[] | undefined;
}>;
type ReadonlyPureSelectorFamily<T, K extends Canonical, E> = Flat<ReadonlyPureSelectorFamilyToken<T, K, E> & {
  create: <Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>;
  default: (key: K) => T;
  install: (store: RootStore) => void;
  internalRoles: string[] | undefined;
}>;
type ReadonlyHeldSelectorFamily<T, K extends Canonical> = Flat<ReadonlyHeldSelectorFamilyToken<T, K> & {
  create: <Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>;
  default: (key: K) => T;
  install: (store: RootStore) => void;
  internalRoles: string[] | undefined;
}>;
type PureSelectorFamily<T, K extends Canonical, E> = ReadonlyPureSelectorFamily<T, K, E> | WritablePureSelectorFamily<T, K, E>;
type HeldSelectorFamily<T, K extends Canonical> = ReadonlyHeldSelectorFamily<T, K> | WritableHeldSelectorFamily<T, K>;
type ReadonlySelectorFamily<T, K extends Canonical, E> = ReadonlyHeldSelectorFamily<T, K> | ReadonlyPureSelectorFamily<T, K, E>;
type WritableSelectorFamily<T, K extends Canonical, E> = WritableHeldSelectorFamily<T, K> | WritablePureSelectorFamily<T, K, E>;
type SelectorFamily<T, K extends Canonical, E> = HeldSelectorFamily<T, K> | PureSelectorFamily<T, K, E>;
type WritableFamily<T, K extends Canonical, E> = AtomFamily<T, K, E> | WritableSelectorFamily<T, K, E>;
type ReadableFamily<T, K extends Canonical, E> = AtomFamily<T, K, E> | SelectorFamily<T, K, E>;
type AtomIOInternalResource = ReadableFamily<any, any, any> | ReadableState<any, any> | Timeline<any> | TimelineFamily<any, any> | Transaction<any>;
//#endregion
//#region src/internal/mutable/get-json-family.d.ts
declare function getJsonFamily<Core extends Transceiver<any, Json.Serializable, Json.Serializable>, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, Key>, store: Store): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key, never>;
//#endregion
//#region src/internal/mutable/get-json-token-from-store.d.ts
declare const getJsonTokenFromStore: <T extends Transceiver<any, any, any>>(store: Store, mutableAtomToken: MutableAtomToken<T>) => WritablePureSelectorToken<AsJSON<T>>;
//#endregion
//#region src/internal/mutable/get-update-family.d.ts
declare function getUpdateFamily<T extends Transceiver<any, Json.Serializable, Json.Serializable>, K extends string>(mutableAtomFamily: MutableAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<SignalFrom<T>, K, never>;
//#endregion
//#region src/internal/mutable/get-update-token.d.ts
declare function getUpdateToken<T extends Transceiver<any, any, any>>(mutableAtomToken: MutableAtomToken<T>): RegularAtomToken<SignalFrom<T>>;
//#endregion
//#region src/internal/mutable/tracker.d.ts
/**
 * @internal Give the tracker a transceiver state and a store, and it will
 * subscribe to the transceiver's inner value. When the inner value changes,
 * the tracker will update its own state to reflect the change.
 */
declare class Tracker<T extends Transceiver<any, any, any>> {
  private initializeSignalAtom;
  private unsubscribeFromInnerValue;
  private unsubscribeFromState;
  private captureSignalsFromCore;
  private supplySignalsToCore;
  mutableAtomToken: MutableAtomToken<T>;
  latestSignalToken: RegularAtomToken<SignalFrom<T> | null>;
  [Symbol.dispose]: () => void;
  constructor(mutableAtomToken: MutableAtomToken<T>, store: Store);
}
//#endregion
//#region src/internal/mutable/tracker-family.d.ts
declare class FamilyTracker<T extends Transceiver<any, any, any>, K extends Canonical> {
  private trackers;
  readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>;
  readonly mutableAtoms: MutableAtomFamily<T, K>;
  constructor(mutableAtoms: MutableAtomFamily<T, K>, store: RootStore);
}
//#endregion
//#region src/internal/store/deposit.d.ts
declare function deposit<T, E>(state: RegularAtom<T, E>): RegularAtomToken<T, Canonical, E>;
declare function deposit<T extends Transceiver<any, any, any>>(state: MutableAtom<T>): MutableAtomToken<T>;
declare function deposit<T, E>(state: Atom<T, E>): AtomToken<T, Canonical, E>;
declare function deposit<T, E>(state: WritablePureSelector<T, E>): WritablePureSelectorToken<T, any, E>;
declare function deposit<T, E>(state: ReadonlyPureSelector<T, E>): ReadonlyPureSelectorToken<T, any, E>;
declare function deposit<T, E>(state: Selector<T, E>): SelectorToken<T, any, E>;
declare function deposit<T, E>(state: WritableState<T, E>): WritableToken<T, any, E>;
declare function deposit<T, E>(state: ReadableState<T, E>): ReadableToken<T, any, E>;
declare function deposit<T, K extends Canonical, E>(state: RegularAtomFamily<T, K, E>): RegularAtomFamilyToken<T, K, E>;
declare function deposit<T extends Transceiver<any, any, any>, K extends Canonical>(state: MutableAtomFamily<T, K>): MutableAtomFamilyToken<T, K>;
declare function deposit<T, E>(state: AtomFamily<T, any, E>): AtomFamilyToken<T, any, E>;
declare function deposit<T, E>(state: WritablePureSelectorFamily<T, any, E>): WritablePureSelectorFamilyToken<T, any, E>;
declare function deposit<T, E>(state: ReadonlyPureSelectorFamily<T, any, E>): ReadonlyPureSelectorFamilyToken<T, any, E>;
declare function deposit<T, E>(state: SelectorFamily<T, any, E>): SelectorFamilyToken<T, any, E>;
declare function deposit<T, E>(state: WritableFamily<T, any, E>): WritableFamilyToken<T, any, E>;
declare function deposit<T, E>(state: ReadableFamily<T, any, E>): ReadableFamilyToken<T, any, E>;
declare function deposit<T extends Fn>(state: Transaction<T>): TransactionToken<T>;
declare function deposit<K extends Canonical, M extends TimelineManageable>(state: TimelineFamily<K, M>): TimelineFamilyToken<K, M>;
declare function deposit<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
//#endregion
//#region src/internal/join/create-join.d.ts
declare function createJoin<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(store: RootStore, options: JoinOptions<AName, A, BName, B, Cardinality>): JoinToken<AName, A, BName, B, Cardinality>;
//#endregion
//#region src/internal/join/edit-relations-in-store.d.ts
declare function editRelationsInStore<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(store: Store, token: JoinToken<AName, A, BName, B, Cardinality>, change: (relations: Junction<AName, A, BName, B>) => void): void;
//#endregion
//#region src/internal/join/find-relations-in-store.d.ts
declare function findRelationsInStore<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(store: Store, token: JoinToken<AName, A, BName, B, Cardinality>, key: A | B): JoinStates<AName, A, BName, B, Cardinality>;
//#endregion
//#region src/internal/join/get-internal-relations-from-store.d.ts
declare function getInternalRelationsFromStore<A extends string, B extends string>(store: Store, token: JoinToken<any, A, any, B, any>): MutableAtomFamilyToken<UList<A> | UList<B>, A | B>;
declare function getInternalRelationsFromStore<A extends string, B extends string>(store: Store, token: JoinToken<any, A, any, B, any>, split: `split`): [atob: MutableAtomFamilyToken<UList<B>, A>, btoa: MutableAtomFamilyToken<UList<A>, B>];
//#endregion
//#region src/internal/join/join-internal.d.ts
type JoinStateFamilies<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>}`]: ReadonlyPureSelectorFamilyToken<A | null, B>; } & { readonly [N in BName as `${N}KeyOf${Capitalize<AName>}`]: ReadonlyPureSelectorFamilyToken<B | null, A>; } : Cardinality extends `1:n` ? { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorFamilyToken<B[], A>; } : Cardinality extends `n:n` ? { readonly [N in AName as `${N}KeysOf${Capitalize<BName>}`]: ReadonlyPureSelectorFamilyToken<A[], B>; } & { readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorFamilyToken<B[], A>; } : never;
declare class 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`> {
  private toolkit;
  options: JoinOptions<AName, A, BName, B, Cardinality>;
  relations: Junction<AName, A, BName, B>;
  states: JoinStateFamilies<AName, A, BName, B, Cardinality>;
  relatedKeysAtoms: MutableAtomFamilyToken<UList<A> | UList<B>, A | B>;
  transact(toolkit: WriterToolkit, run: (join: Join<AName, A, BName, B, Cardinality>) => void): void;
  store: Store;
  [Symbol.dispose](): void;
  constructor(store: RootStore, options: JoinOptions<AName, A, BName, B, Cardinality>);
}
//#endregion
//#region src/internal/join/get-join.d.ts
declare function getJoin<AName extends string, A extends string, BName extends string, B extends string, Cardinality extends `1:1` | `1:n` | `n:n`>(store: Store, token: JoinToken<AName, A, BName, B, Cardinality>): Join<AName, A, BName, B, Cardinality>;
//#endregion
//#region src/internal/lineage.d.ts
interface Lineage {
  parent: Lineage | null;
  child: Lineage | null;
}
declare function newest<T extends Lineage>(origin: T): Exclude<T[`child`], null> | T;
declare function eldest<T extends Lineage>(origin: T): Exclude<T[`parent`], T[`child`] | null>;
//#endregion
//#region src/internal/molecule.d.ts
type Molecule<K extends Canonical> = {
  readonly key: K;
  readonly stringKey: stringified<K>;
  readonly dependsOn: `all` | `any`;
  readonly subject: Subject<void>;
};
declare function simpleCompound(a: string, b: string): string;
declare function decomposeCompound(compound: Canonical): [type: string, a: string, b: string] | null;
declare function makeRootMoleculeInStore<S extends string>(store: Store, key: S): S;
declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V, dependsOn?: `all` | `any`): ValidKey<V>;
declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends (C extends CompoundTypedKey<infer t, any, any> ? t : never), A extends (C extends CompoundTypedKey<any, infer a, any> ? a : never), B extends (C extends CompoundTypedKey<any, any, infer b> ? b : never)>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): ValidKey<CompoundTypedKey<T, A, B>>;
declare function createDeallocateTX<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>>(store: RootStore): TransactionToken<(claim: ValidKey<V>) => void>;
declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(target: Store, claim: ValidKey<V>): void;
declare function createClaimTX<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: RootStore): TransactionToken<(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`) => void>;
declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: Store, newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`): ValidKey<V>;
//#endregion
//#region src/internal/operation.d.ts
type OperationProgress = OpenOperation<any> | {
  open: false;
};
type OpenOperation<R extends ReadableToken<any, any> = ReadableToken<any, any>> = {
  open: true;
  token: R;
  done: Set<string>;
  prev: Map<string, any>;
  timestamp: number;
  subEvents: (AtomUpdateEvent<any> | AtomCreationEvent<any>)[];
};
declare function openOperation(store: Store, token: ReadableToken<any, any, any>): number | (Store & {
  operation: OpenOperation;
});
declare function closeOperation(store: Store): void;
declare function isDone(store: Store, key: string): boolean;
declare function markDone(store: Store, key: string): void;
//#endregion
//#region src/internal/store/store.d.ts
type StoreConfig = {
  name: string;
  lifespan: `ephemeral` | `immortal`;
  isProduction: boolean;
};
declare class Store implements Lineage {
  parent: ChildStore | RootStore | null;
  child: ChildStore | null;
  valueMap: Map<string, any>;
  defaults: Map<string, any>;
  atoms: Map<string, Atom<any, any>>;
  writableSelectors: Map<string, WritableSelector<any, any>>;
  readonlySelectors: Map<string, ReadonlySelector<any, any>>;
  atomsThatAreDefault: Set<string>;
  selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string>;
  selectorGraph: Junction<`upstreamSelectorKey`, string, `downstreamSelectorKey`, string, {
    source: string;
  }>;
  trackers: Map<string, Tracker<Transceiver<any, any, any>>>;
  families: Map<string, HeldSelectorFamily<any, any> | MutableAtomFamily<any, any> | PureSelectorFamily<any, any, any> | RegularAtomFamily<any, any, any>>;
  joins: Map<string, Join<any, any, any, any, any>>;
  transactions: Map<string, Transaction<Fn>>;
  transactionMeta: RootTransactionMeta | TransactionProgress<Fn>;
  timelines: Map<string, Timeline<any>>;
  timelineFamilies: Map<string, TimelineFamily<any, any>>;
  timelineTopics: Junction<`timelineKey`, string, `topicKey`, string, {
    topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
  }>;
  disposalTraces: CircularBuffer<{
    key: string;
    trace: string;
  }>;
  molecules: Map<string, Molecule<Canonical>>;
  moleculeGraph: Junction<`upstreamMoleculeKey`, stringified<Canonical> | `"root"`, `downstreamMoleculeKey`, stringified<Canonical>, {
    source: stringified<Canonical>;
  }>;
  moleculeData: Junction<`moleculeKey`, stringified<Canonical>, `stateFamilyKey`, string>;
  keyRefsInJoins: Junction<`moleculeKey`, stringified<Canonical>, `joinKey`, string>;
  miscResources: Map<string, Disposable>;
  on: StoreEventCarrier;
  operation: OperationProgress;
  config: StoreConfig;
  loggers: AtomIOLogger[];
  logger: Logger;
  constructor(config: Store[`config`], store?: Store | null);
}
type StoreEventCarrier = {
  atomCreation: Subject<AtomToken<unknown, any, any>>;
  atomDisposal: Subject<AtomToken<unknown, any, any>>;
  selectorCreation: Subject<SelectorToken<unknown, any, any>>;
  selectorDisposal: Subject<SelectorToken<unknown, any, any>>;
  timelineCreation: Subject<TimelineToken<unknown>>;
  timelineDisposal: Subject<TimelineToken<unknown>>;
  transactionCreation: Subject<TransactionToken<Fn>>;
  transactionApplying: StatefulSubject<TransactionProgress<Fn> | null>;
  operationClose: Subject<OperationProgress>;
  moleculeCreation: Subject<MoleculeCreationEvent>;
  moleculeDisposal: Subject<MoleculeDisposalEvent>;
};
declare global {
  var ATOM_IO_IMPLICIT_STORE: RootStore | undefined;
}
declare const IMPLICIT: {
  readonly STORE: RootStore;
};
declare function clearStore(store: Store): void;
//#endregion
//#region src/internal/store/withdraw.d.ts
declare function withdraw<T, E>(store: Store, token: RegularAtomToken<T, any, E>): RegularAtom<T, E>;
declare function withdraw<T extends Transceiver<any, any, any>>(store: Store, token: MutableAtomToken<T, any>): MutableAtom<T>;
declare function withdraw<T, E>(store: Store, token: AtomToken<T, any, E>): Atom<T, E>;
declare function withdraw<T>(store: Store, token: WritableHeldSelectorToken<T>): WritableHeldSelector<T>;
declare function withdraw<T>(store: Store, token: ReadonlyHeldSelectorToken<T>): ReadonlyHeldSelector<T>;
declare function withdraw<T, E>(store: Store, token: WritablePureSelectorToken<T, any, E>): WritablePureSelector<T, E>;
declare function withdraw<T, E>(store: Store, token: ReadonlyPureSelectorToken<T, any, E>): ReadonlyPureSelector<T, E>;
declare function withdraw<T, E>(store: Store, token: ReadonlySelectorToken<T, any, E>): ReadonlySelector<T, E>;
declare function withdraw<T, E>(store: Store, token: WritableSelectorToken<T, any, E>): WritableSelector<T, E>;
declare function withdraw<T>(store: Store, token: HeldSelectorToken<T>): HeldSelector<T>;
declare function withdraw<T, E>(store: Store, token: PureSelectorToken<T, any, E>): PureSelector<T, E>;
declare function withdraw<T, E>(store: Store, token: SelectorToken<T, any, E>): Selector<T, E>;
declare function withdraw<T, E>(store: Store, token: WritableToken<T, any, E>): WritableState<T, E>;
declare function withdraw<T, E>(store: Store, token: ReadableToken<T, any, E>): ReadableState<T, E>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: RegularAtomFamilyToken<T, K, E>): RegularAtomFamily<T, K, E>;
declare function withdraw<T extends Transceiver<any, any, any>, K extends Canonical>(store: Store, token: MutableAtomFamilyToken<T, K>): MutableAtomFamily<T, K>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: AtomFamilyToken<T, K, E>): AtomFamily<T, K, E>;
declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlyHeldSelectorFamilyToken<T, K>): ReadonlyHeldSelectorFamily<T, K>;
declare function withdraw<T, K extends Canonical>(store: Store, token: WritableHeldSelectorFamilyToken<T, K>): WritableHeldSelectorFamily<T, K>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K, E>): ReadonlyPureSelectorFamily<T, K, E>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: WritablePureSelectorFamilyToken<T, K, E>): WritablePureSelectorFamily<T, K, E>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: ReadonlySelectorFamilyToken<T, K, E>): ReadonlySelectorFamily<T, K, E>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: WritableSelectorFamilyToken<T, K, E>): WritableSelectorFamily<T, K, E>;
declare function withdraw<T, K extends Canonical>(store: Store, token: HeldSelectorFamilyToken<T, K>): HeldSelectorFamily<T, K>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: PureSelectorFamilyToken<T, K, E>): PureSelectorFamily<T, K, E>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: SelectorFamilyToken<T, K, E>): SelectorFamily<T, K, E>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: WritableFamilyToken<T, K, E>): WritableFamily<T, K, E>;
declare function withdraw<T, K extends Canonical, E>(store: Store, token: ReadableFamilyToken<T, K, E>): ReadableFamily<T, K, E>;
declare function withdraw<T extends Fn>(store: Store, token: TransactionToken<T>): Transaction<T extends Fn ? T : never>;
declare function withdraw<K extends Canonical, M extends TimelineManageable>(store: Store, token: TimelineFamilyToken<K, M>): TimelineFamily<K, M>;
declare function withdraw<T>(store: Store, token: TimelineToken<T>): Timeline<T extends TimelineManageable ? T : never>;
declare function withdraw<T, E>(store: Store, token: WritableToken<T, any, E>): WritableState<T, E>;
declare function withdraw<T, E>(store: Store, token: ReadableToken<T, any, E>): ReadableState<T, E>;
declare function withdraw(store: Store, token: AtomIOToken): AtomIOInternalResource;
//#endregion
//#region src/internal/atom/has-role.d.ts
declare const INTERNAL_ROLES: readonly ["tracker:signal"];
type InternalRole = (typeof INTERNAL_ROLES)[number];
declare function hasRole(atom: Atom<any, any>, role: InternalRole): boolean;
//#endregion
//#region src/internal/atom/create-regular-atom.d.ts
declare function createRegularAtom<T, K extends Canonical, E>(store: Store, options: RegularAtomOptions<T, E>, family: FamilyMetadata<K> | undefined, internalRoles?: InternalRole[]): RegularAtomToken<T, K, E>;
//#endregion
//#region src/internal/atom/dispose-atom.d.ts
declare function disposeAtom(store: Store, atomToken: AtomToken<any, any, any>): void;
//#endregion
//#region src/internal/caching.d.ts
declare function writeToCache<T, E>(target: Store, state: ReadableState<T, E>, value: E | T): E | T;
declare function writeToCache<T extends Promise<any>, E>(target: Store, state: ReadableState<T, E>, value: T): Future<Awaited<E | T>>;
/**
 * @param target - the newest layer of the store
 * @param state - the state to read from cache
 * @param mut - whether the value is intended to be mutable
 * @returns the state's current value
 */
declare function readFromCache<T, E>(target: Store, state: ReadableState<T, E>, mut: `mut` | undefined): E | T;
declare function evictCachedValue(target: Store, key: string): void;
//#endregion
//#region src/internal/capitalize.d.ts
declare function capitalize<S extends string>(string: S): Capitalize<S>;
//#endregion
//#region src/internal/events/ingest-atom-update.d.ts
declare function ingestAtomUpdateEvent(store: Store, event: AtomUpdateEvent<any>, applying: `newValue` | `oldValue`): void;
//#endregion
//#region src/internal/events/ingest-creation-disposal.d.ts
declare function ingestCreationEvent(store: Store, event: AtomCreationEvent<any>, applying: `newValue` | `oldValue`): void;
declare function ingestDisposalEvent(store: Store, event: AtomDisposalEvent<any>, applying: `newValue` | `oldValue`): void;
declare function ingestMoleculeCreationEvent(store: Store, event: MoleculeCreationEvent, applying: `newValue` | `oldValue`): void;
declare function ingestMoleculeDisposalEvent(store: Store, event: MoleculeDisposalEvent, applying: `newValue` | `oldValue`): void;
declare function ingestMoleculeTransferEvent(store: Store, event: MoleculeTransferEvent, applying: `newValue` | `oldValue`): void;
//#endregion
//#region src/internal/events/ingest-selector-update.d.ts
declare function ingestSelectorUpdateEvent(store: Store, selectorUpdate: TimelineSelectorUpdateEvent<any>, applying: `newValue` | `oldValue`): void;
//#endregion
//#region src/internal/events/ingest-transaction-update.d.ts
declare function ingestTransactionOutcomeEvent<T extends TransactionToken<any>>(store: Store, event: TransactionOutcomeEvent<T>, applying: `newValue` | `oldValue`): void;
//#endregion
//#region src/internal/families/create-readonly-pure-selector-family.d.ts
declare function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T, K, E>, internalRoles?: string[]): ReadonlyPureSelectorFamilyToken<T, K, E>;
//#endregion
//#region src/internal/families/create-regular-atom-family.d.ts
declare function createRegularAtomFamily<T, K extends Canonical, E>(store: RootStore, options: RegularAtomFamilyOptions<T, K, E>, internalRoles?: string[]): RegularAtomFamilyToken<T, K, E>;
//#endregion
//#region src/internal/families/create-selector-family.d.ts
declare function createSelectorFamily<T extends object, K extends Canonical>(store: RootStore, options: WritableHeldSelectorFamilyOptions<T, K>): WritableHeldSelectorFamilyToken<T, K>;
declare function createSelectorFamily<T extends object, K extends Canonical>(store: RootStore, options: ReadonlyHeldSelectorFamilyOptions<T, K>): ReadonlyHeldSelectorFamilyToken<T, K>;
declare function createSelectorFamily<T, K extends Canonical, E>(store: RootStore, options: WritablePureSelectorFamilyOptions<T, K, E>): WritablePureSelectorFamilyToken<T, K, E>;
declare function createSelectorFamily<T, K extends Canonical, E>(store: RootStore, options: ReadonlyPureSelectorFamilyOptions<T, K, E>): ReadonlyPureSelectorFamilyToken<T, K, E>;
//#endregion
//#region src/internal/families/create-writable-pure-selector-family.d.ts
declare function createWritablePureSelectorFamily<T, K extends Canonical, E>(store: Store, options: WritablePureSelectorFamilyOptions<T, K, E>, internalRoles?: string[]): WritablePureSelectorFamilyToken<T, K, E>;
//#endregion
//#region src/internal/families/dispose-from-store.d.ts
declare function disposeFromStore(store: Store, token: ReadableToken<any, any, any>): void;
declare function disposeFromStore<K extends Canonical>(store: Store, token: ReadableFamilyToken<any, K, any>, key: NoInfer<K>): void;
declare function disposeFromStore<K extends Canonical>(store: Store, ...params: [token: ReadableFamilyToken<any, K, any>, key: NoInfer<K>] | [token: ReadableToken<any, any, any>]): void;
//#endregion
//#region src/internal/families/find-in-store.d.ts
declare function findInStore<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(store: Store, familyToken: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, Key>;
declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: RegularAtomFamilyToken<T, K, E>, key: Key): RegularAtomToken<T, Key, E>;
declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: AtomFamilyToken<T, K, E>, key: Key): AtomToken<T, Key, E>;
declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: WritablePureSelectorFamilyToken<T, K, E>, key: Key): WritablePureSelectorToken<T, Key, E>;
declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: ReadonlyPureSelectorFamilyToken<T, K, E>, key: Key): ReadonlyPureSelectorToken<T, Key, E>;
declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: SelectorFamilyToken<T, K, E>, key: Key): SelectorToken<T, Key, E>;
declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: WritableFamilyToken<T, K, E>, key: Key): WritableToken<T, Key, E>;
declare function findInStore<T, K extends Canonical, Key extends K, E>(store: Store, familyToken: ReadableFamilyToken<T, K, E>, key: Key): ReadableToken<T, Key, E>;
//#endregion
//#region src/internal/families/get-family-of-token.d.ts
declare function getFamilyOfToken<T extends Transceiver<any, any, any>, K extends Canonical>(store: Store, token: MutableAtomToken<T, K>): MutableAtomFamily<T, K>;
declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: RegularAtomToken<T, K, E>): RegularAtomFamily<T, K, E>;
declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: AtomToken<T, K, E>): AtomFamily<T, K, E>;
declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: WritablePureSelectorToken<T, K, E>): WritablePureSelectorFamily<T, K, E>;
declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: ReadonlyPureSelectorToken<T, K, E>): ReadonlyPureSelectorFamily<T, K, E>;
declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: WritableToken<T, K, E>): WritableFamily<T, K, E>;
declare function getFamilyOfToken<T, K extends Canonical, E>(store: Store, token: ReadableToken<T, K, E>): ReadableFamily<T, K, E>;
//#endregion
//#region src/internal/families/seek-in-store.d.ts
declare function seekInStore<T extends Transceiver<any, any, any>, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, Key> | undefined;
declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: RegularAtomFamilyToken<T, K, E>, key: Key): RegularAtomToken<T, Key, E> | undefined;
declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: AtomFamilyToken<T, K, E>, key: Key): AtomToken<T, Key, E> | undefined;
declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: WritablePureSelectorFamilyToken<T, K, E>, key: Key): WritablePureSelectorToken<T, Key, E> | undefined;
declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K, E>, key: Key): ReadonlyPureSelectorToken<T, Key, E> | undefined;
declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: SelectorFamilyToken<T, K, E>, key: Key): SelectorToken<T, Key, E> | undefined;
declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: WritableFamilyToken<T, K, E>, key: Key): WritableToken<T, Key, E> | undefined;
declare function seekInStore<T, K extends Canonical, Key extends K, E>(store: Store, token: ReadableFamilyToken<T, K, E>, key: Key): ReadableToken<T, Key, E> | undefined;
//#endregion
//#region src/internal/get-environment-data.d.ts
type EnvironmentData = {
  store: Store;
};
declare function getEnvironmentData(store: Store): EnvironmentData;
//#endregion
//#region src/internal/get-state/get-from-store.d.ts
declare function getFromStore<T, E = never>(store: Store, token: ReadableToken<T, any, E>): ViewOf<E | T>;
declare function getFromStore<T, K extends Canonical, E = never>(store: Store, token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>): ViewOf<E | T>;
declare function getFromStore<T, K extends Canonical, E = never>(store: Store, ...params: [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>] | [token: ReadableToken<T, any, E>]): ViewOf<E | T>;
//#endregion
//#region src/internal/get-state/read-or-compute-value.d.ts
declare function readOrComputeValue<T, E>(target: Store, state: ReadableState<T, E>, mut?: undefined): ViewOf<E | T>;
declare function readOrComputeValue<T, E>(target: Store, state: ReadableState<T, E>, mut: `mut`): E | T;
//#endregion
//#region src/internal/get-trace.d.ts
declare function getTrace(error: Error): string;
//#endregion
//#region src/internal/install-into-store.d.ts
/**
 * @public
 * Install the given tokens into the target store
 * @param tokens - States, families, transactions, and timelines to install into the target store
 * @param target - The store to install the tokens into
 * @param source - The store to install the tokens from
 *
 */
declare function installIntoStore(tokens: AtomIOToken[], target: RootStore, source: Store): void;
//#endregion
//#region src/internal/is-fn.d.ts
declare function isFn(input: unknown): input is Fn;
//#endregion
//#region src/internal/keys.d.ts
type AtomKey<T> = string & {
  __atomKey?: never;
  __brand?: T;
};
type SelectorKey<T> = string & {
  __selectorKey?: never;
  __brand?: T;
};
type ReadonlySelectorKey<T> = string & {
  __readonlySelectorKey?: never;
  __brand?: T;
};
declare const isAtomKey: (store: Store, key: string) => key is AtomKey<unknown>;
declare const isSelectorKey: (store: Store, key: string) => key is SelectorKey<unknown>;
declare const isReadonlySelectorKey: (store: Store, key: string) => key is ReadonlySelectorKey<unknown>;
type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
declare const isStateKey: (store: Store, key: string) => key is StateKey<unknown>;
//#endregion
//#region src/internal/reserved-keys.d.ts
type ReservedIntrospectionKey = `🔍 ${string}`;
declare function isReservedIntrospectionKey(value: string): value is ReservedIntrospectionKey;
//#endregion
//#region src/internal/selector/create-readonly-held-selector.d.ts
declare function createReadonlyHeldSelector<T extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T>, family: FamilyMetadata | undefined): ReadonlyHeldSelectorToken<T>;
//#endregion
//#region src/internal/selector/create-readonly-pure-selector.d.ts
declare function createReadonlyPureSelector<T, K extends Canonical, E>(store: Store, options: ReadonlyPureSelectorOptions<T, E>, family: FamilyMetadata<K> | undefined): ReadonlyPureSelectorToken<T, K, E>;
//#endregion
//#region src/internal/selector/create-standalone-selector.d.ts
declare function createStandaloneSelector<T extends object>(store: Store, options: WritableHeldSelectorOptions<T>): WritableHeldSelectorToken<T>;
declare function createStandaloneSelector<T extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T>): ReadonlyHeldSelectorToken<T>;
declare function createStandaloneSelector<T, E>(store: Store, options: WritablePureSelectorOptions<T, E>): WritablePureSelectorToken<T, any, E>;
declare function createStandaloneSelector<T, E>(store: Store, options: ReadonlyPureSelectorOptions<T, E>): ReadonlyPureSelectorToken<T, any, E>;
//#endregion
//#region src/internal/selector/create-writable-held-selector.d.ts
declare function createWritableHeldSelector<T extends object>(store: Store, options: WritableHeldSelectorOptions<T>, family: FamilyMetadata | undefined): WritableHeldSelectorToken<T>;
//#endregion
//#region src/internal/selector/create-writable-pure-selector.d.ts
declare function createWritablePureSelector<T, K extends Canonical, E>(store: Store, options: WritablePureSelectorOptions<T, E>, family: FamilyMetadata<K> | undefined): WritablePureSelectorToken<T, K, E>;
//#endregion
//#region src/internal/selector/dispose-selector.d.ts
declare function disposeSelector(store: Store, selectorToken: SelectorToken<unknown, any, any>): void;
//#endregion
//#region src/internal/selector/get-selector-dependency-keys.d.ts
declare function getSelectorDependencyKeys(store: Store, key: string): (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
//#endregion
//#region src/internal/selector/register-selector.d.ts
declare function registerSelector(store: Store, selectorType: `readonly_held_selector` | `readonly_pure_selector` | `writable_held_selector` | `writable_pure_selector`, selectorKey: string, covered: Set<string>): WriterToolkit;
//#endregion
//#region src/internal/selector/trace-selector-atoms.d.ts
declare function traceRootSelectorAtoms(store: Store, selectorKey: string, covered?: Set<string>): Map<string, Atom<any, any>>;
//#endregion
//#region src/internal/selector/update-selector-atoms.d.ts
declare function updateSelectorAtoms(store: Store, selectorType: `readonly_held_selector` | `readonly_pure_selector` | `writable_held_selector` | `writable_pure_selector`, selectorKey: string, dependency: ReadableToken<unknown, any, unknown>, covered: Set<string>): void;
//#endregion
//#region src/internal/set-state/become.d.ts
declare function become<T>(nextVersionOfThing: T | ((prev: T) => T), originalThing: T): T;
//#endregion
//#region src/internal/set-state/evict-downstream.d.ts
declare function evictDownstreamFromAtom(store: Store, atom: Atom<any, any>): void;
declare function evictDownstreamFromSelector(store: Store, selectorKey: string): void;
//#endregion
//#region src/internal/set-state/reset-in-store.d.ts
declare const RESET_STATE: unique symbol;
declare function resetInStore(store: Store, token: WritableToken<any, any, any>): void;
declare function resetInStore<K extends Canonical>(store: Store, token: WritableFamilyToken<any, K, any>, key: NoInfer<K>): void;
declare function resetInStore<T, K extends Canonical>(store: Store, ...params: [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>] | [token: WritableToken<T, any, any>]): void;
//#endregion
//#region src/internal/set-state/operate-on-store.d.ts
type ProtoUpdate<T> = {
  oldValue?: T;
  newValue: T;
};
declare const OWN_OP: unique symbol;
declare const JOIN_OP: unique symbol;
declare function operateOnStore<T, TT extends T, K extends Canonical, E>(opMode: typeof JOIN_OP | typeof OWN_OP, store: Store, ...params: [token: WritableFamilyToken<T, K, E>, key: NoInfer<K>, value: Setter<TT> | TT | typeof RESET_STATE] | [token: WritableToken<T, any, E>, value: Setter<TT> | TT | typeof RESET_STATE]): void;
//#endregion
//#region src/internal/set-state/reset-atom-or-selector.d.ts
declare function resetAtomOrSelector<T, E>(target: Store & {
  operation: OpenOperation;
}, state: WritableState<T, E>): ProtoUpdate<E | T>;
//#endregion
//#region src/internal/set-state/set-atom-or-selector.d.ts
declare function setAtomOrSelector<T>(target: Store & {
  operation: OpenOperation;
}, state: WritableState<T, any>, value: NoInfer<T> | ((oldValue: T) => NoInfer<T>)): ProtoUpdate<T>;
//#endregion
//#region src/internal/set-state/set-into-store.d.ts
declare function setIntoStore<T, TT extends T>(store: Store, token: WritableToken<T, any, any>, value: Setter<TT> | TT | typeof RESET_STATE): void;
declare function setIntoStore<T, TT extends T, K extends Canonical>(store: Store, token: WritableFamilyToken<T, K, any>, key: NoInfer<K>, value: Setter<TT> | TT | typeof RESET_STATE): void;
declare function setIntoStore<T, TT extends T, K extends Canonical>(store: Store, ...params: [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>, value: Setter<TT> | TT | typeof RESET_STATE] | [token: WritableToken<T, any, any>, value: Setter<TT> | TT | typeof RESET_STATE]): void;
//#endregion
//#region src/internal/subscribe/recall-state.d.ts
declare function recallState<T, E>(store: Store, state: ReadableState<T, E>): T;
//#endregion
//#region src/internal/subscribe/subscribe-in-store.d.ts
declare function subscribeInStore<T>(store: Store, token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
declare function subscribeInStore<F extends Fn>(store: Store, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
declare function subscribeInStore<M extends TimelineManageable>(store: Store, token: TimelineToken<M>, handleUpdate: (update: TimelineEvent<M> | `clear` | `redo` | `undo`) => void, key?: string): () => void;
declare function subscribeInStore<K extends Canonical, M extends TimelineManageable>(store: RootStore, family: TimelineFamilyToken<K, M>, memberKey: NoInfer<K>, handleUpdate: (update: TimelineUpdate<M>) => void, key?: string): () => void;
declare function subscribeInStore<M extends TimelineManageable>(store: Store, ...params: [token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>, handleUpdate: TransactionUpdateHandler<any> | UpdateHandler<any> | ((update: TimelineUpdate<M>) => void), key?: string] | [family: TimelineFamilyToken<Canonical, M>, memberKey: Canonical, handleUpdate: (update: TimelineUpdate<M>) => void, key?: string]): () => void;
//#endregion
//#region src/internal/subscribe/subscribe-to-root-atoms.d.ts
declare function subscribeToRootDependency(target: Store, selector: Selector<any, any>, atom: Atom<any, any>): () => void;
//#endregion
//#region src/internal/subscribe/subscribe-to-state.d.ts
declare function subscribeToState<T, E>(store: Store, token: ReadableToken<T, any, E>, key: string, handleUpdate: UpdateHandler<E | T>): () => void;
//#endregion
//#region src/internal/subscribe/subscribe-to-timeline.d.ts
declare function subscribeToTimeline<ManagedAtom extends TimelineManageable>(store: Store, token: TimelineToken<ManagedAtom>, key: string, handleUpdate: (update: TimelineUpdate<ManagedAtom>) => void): () => void;
//#endregion
//#region src/internal/subscribe/subscribe-to-transaction.d.ts
declare function subscribeToTransaction<F extends Fn>(store: Store, token: TransactionToken<F>, key: string, handleUpdate: TransactionUpdateHandler<F>): () => void;
//#endregion
export { AsJSON, type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, AtomKey, ChildStore, CircularBuffer, ConstructorOf, type Count, type Ctor, type Each, EnvironmentData, FamilyTracker, type Fn, GroupedTimelineTransactionEvent, type HeldSelector, type HeldSelectorFamily, IMPLICIT, INTERNAL_ROLES, InternalRole, JOIN_OP, Join, JoinStateFamilies, Lineage, Molecule, type MutableAtom, type MutableAtomFamily, OWN_OP, OpenOperation, OperationProgress, ProtoUpdate, type PureSelector, type PureSelectorFamily, RESET_STATE, type ReadableFamily, type ReadableState, type ReadonlyHeldSelector, type ReadonlyHeldSelectorFamily, type ReadonlyPureSelector, type ReadonlyPureSelectorFamily, type ReadonlySelector, type ReadonlySelectorFamily, ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, ReservedIntrospectionKey, RootStore, RootTransactionMeta, type Selector, type SelectorFamily, SelectorKey, SignalFrom, StateKey, Store, StoreConfig, StoreEventCarrier, TIMELINE_TRANSACTION_GROUP, TRANSACTION_PHASES, Timeline, TimelineFamily, TimelineInspection, TimelineTransactionGroup, Tracker, Transaction, TransactionPhase, TransactionProgress, Transceiver, TransceiverConstructor, TransceiverMode, TransceiverTimelinePolicy, type WritableFamily, type WritableHeldSelector, type WritableHeldSelectorFamily, type WritablePureSelector, type WritablePureSelectorFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, addTimelineToTransactionGroup, allocateIntoStore, applyTransaction, arbitrary, become, buildTransaction, capitalize, claimWithinStore, clearStore, clearTimelineInStore, closeOperation, createClaimTX, createDeallocateTX, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTimelineFamily, createTimelineFamilyMember, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, decomposeCompound, deposit, disposeAtom, disposeFromStore, disposeSelector, disposeTimelineInStore, editRelationsInStore, eldest, evictCachedValue, evictDownstreamFromAtom, evictDownstreamFromSelector, findInStore, findRelationsInStore, findTimelineInStore, fuseWithinStore, getEnvironmentData, getFamilyOfToken, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonTokenFromStore, getSelectorDependencyKeys, getTimelineTransactionAtHead, getTimelineTransactionGroup, getTrace, getUpdateFamily, getUpdateToken, handleStateLifecycleEvent, hasRole, ingestAtomUpdateEvent, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdateEvent, ingestTransactionOutcomeEvent, inspectTimelineInStore, installIntoStore, isAtomKey, isChildStore, isDone, isFn, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, operateOnStore, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, seekTimelineInStore, setAtomOrSelector, setIntoStore, simpleCompound, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, timeTravelTransactionGroupInStore, timeTravelTransactionInStore, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
//# sourceMappingURL=index.d.ts.map