import { Each, RootStore, decomposeCompound, simpleCompound } from "atom.io/internal";
import { primitive } from "atom.io/foundations/json";
import { OList } from "atom.io/transceivers/o-list";
import { UList } from "atom.io/transceivers/u-list";
import { AtomEffect, TransactionToken } from "atom.io";
import { Canonical } from "atom.io/foundations/canonical";
//#region src/experiments/realms/o-list-disposed-key-cleanup-effect.d.ts
declare function filterOutInPlace<T>(arr: T[], toRemove: T): T[];
declare const oListDisposedKeyCleanupEffect: AtomEffect<OList<primitive>>;
//#endregion
//#region src/experiments/realms/realm.d.ts
declare const $validatedKey: unique symbol;
type ValidKey<K extends Canonical> = K & {
  [$validatedKey]?: true;
};
declare class Realm<H extends Hierarchy> {
  store: RootStore;
  deallocateTX: TransactionToken<(claim: ValidKey<Vassal<H>>) => void>;
  claimTX: TransactionToken<<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`) => void>;
  /**
   * @param store - The store to which the realm will be attached
   */
  constructor(store?: RootStore);
  /**
   * Make space for a new subject of the realm
   * @param provenance - A key for an owner {@link Above} the new subject in the realm's {@link Hierarchy}
   * @param key - A unique identifier for the new subject
   * @param attachmentStyle - The attachment style of new subject to its owner(s). `any` means that if any owners remain, the subject will be retained. `all` means that the subject be retained only if all owners remain .
   * @returns
   * The subject's key, given status as a true {@link ValidKey}
   */
  allocate<V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V, attachmentStyle?: `all` | `any`): ValidKey<V>;
  /**
   * Fuse two reagents into a compound
   * @param type - the name of the compound that is being fused
   * @param reagentA - the left reagent of the compound
   * @param reagentB - the right reagent of the compound
   * @returns
   * The compound's key, given status as a {@link ValidKey}
   */
  fuse<C extends CompoundFrom<H>, T extends (C extends CompoundTypedKey<infer t, any, any> ? t : never), A extends (C extends CompoundTypedKey<any, infer v, any> ? v : never), B extends (C extends CompoundTypedKey<any, any, infer m> ? m : never)>(type: T, reagentA: SingularTypedKey<A>, reagentB: SingularTypedKey<B>): ValidKey<CompoundTypedKey<T, A, B>>;
  /**
   * Remove a subject from the realm
   * @param claim - The subject to be deallocated
   */
  deallocate<V extends Vassal<H>>(claim: ValidKey<V>): void;
  /**
   * Transfer a subject of the realm from one owner to another
   * @param newProvenance - A key for an owner {@link Above} the new subject in the realm's {@link Hierarchy}
   * @param claim - The subject to be claimed
   * @param exclusive - Whether the subjects previous owners should be detached from it
   * @returns
   * The subject's key, given status as a true {@link ValidKey}
   */
  claim<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`): void;
}
declare class Anarchy {
  store: RootStore;
  deallocateTX: TransactionToken<(key: Canonical) => void>;
  claimTX: TransactionToken<(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`) => void>;
  /**
   * @param store - The store to which the anarchy-realm will be attached
   */
  constructor(store?: RootStore);
  /**
   * Declare a new entity
   * @param provenance - A key for an owner of the entity
   * @param key - A unique identifier for the new entity
   * @param attachmentStyle - The attachment style of new entity to its owner(s). `any` means that if any owners remain, the subject will be retained. `all` means that the subject be retained only if all owners remain .
   */
  allocate(provenance: Canonical, key: Canonical, attachmentStyle?: `all` | `any`): void;
  /**
   * Remove an entity
   * @param key - The entity to be deallocated
   */
  deallocate(key: Canonical): void;
  /**
   * Transfer an entity from one owner to another
   * @param newProvenance - A key for an owner of the entity
   * @param key - The entity to be claimed
   * @param exclusive - Whether the entity's previous owners should be detached from it
   */
  claim(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`): void;
  /**
   * Fuse two reagents into a compound
   * @param type - the name of the compound that is being fused
   * @param reagentA - the left reagent of the compound
   * @param reagentB - the right reagent of the compound
   * @returns
   * The compound's key, given status as a {@link ValidKey}
   */
  fuse<T extends string, A extends string, B extends string>(type: T, reagentA: SingularTypedKey<A>, reagentB: SingularTypedKey<B>): ValidKey<CompoundTypedKey<T, A, B>>;
}
type T$ = `T$`;
type TypeTag<T extends string> = `${T$}--${T}`;
type SingularTypedKey<T extends string = string> = `${T}::${string}`;
type CompoundTypedKey<T extends string = string, A extends string = string, B extends string = string> = `${TypeTag<T>}==${SingularTypedKey<A>}++${SingularTypedKey<B>}`;
type TypedKey<T extends string = string, A extends string = string, B extends string = string> = CompoundTypedKey<T, A, B> | SingularTypedKey<T>;
type Scope = SingularTypedKey[];
type MutualFealty = {
  above: Scope;
  below: CompoundTypedKey;
};
type ExclusiveFealty = {
  above: TypedKey | `root`;
  below: Scope;
};
type Fealty = ExclusiveFealty | MutualFealty;
type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
type Vassal<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
  below: Array<infer V>;
} ? V extends TypedKey ? V : never : never; }[keyof H];
type Above<TK extends TypedKey, H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
  below: Array<infer V>;
} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never; }[keyof H];
type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`] ? H[K][`below`] : TK extends H[K][`above`][number] ? H[K][`below`] : never : H[K] extends {
  above: infer V;
} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`below`][number] : never : never : never; }[keyof H];
type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`above`][number] ? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]] : never : never; }[keyof H];
type CompoundFrom<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never; }[keyof H];
//#endregion
//#region src/experiments/realms/u-list-disposed-key-cleanup-effect.d.ts
declare const uListDisposedKeyCleanupEffect: AtomEffect<UList<primitive>>;
//#endregion
export { $validatedKey, Above, Anarchy, Below, CompoundFrom, CompoundTypedKey, Hierarchy, Mutuals, Realm, SingularTypedKey, T$, TypeTag, TypedKey, ValidKey, Vassal, decomposeCompound, filterOutInPlace, oListDisposedKeyCleanupEffect, simpleCompound, uListDisposedKeyCleanupEffect };
//# sourceMappingURL=index.d.ts.map