import { Fn, Refinement, RootStore, Store, Timeline } from "atom.io/internal";
import { Json } from "atom.io/foundations/json";
import { AtomToken, Loadable, ReadableToken, ReadonlyPureSelectorFamilyToken, SelectorToken, TimelineToken, TransactionOutcomeEvent, TransactionToken } from "atom.io";
import { Flat } from "atom.io/foundations/type-utils";
//#region src/introspection/attach-atom-index.d.ts
type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown, any, unknown>>;
//#endregion
//#region src/introspection/attach-selector-index.d.ts
type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown, any, any>>;
//#endregion
//#region src/introspection/attach-introspection-states.d.ts
type IntrospectionStates = {
  atomIndex: AtomToken<AtomTokenIndex>;
  selectorIndex: AtomToken<SelectorTokenIndex>;
  transactionIndex: AtomToken<TransactionToken<Fn>[]>;
  transactionLogSelectors: ReadonlyPureSelectorFamilyToken<readonly TransactionOutcomeEvent<TransactionToken<Fn>>[], string>;
  timelineIndex: AtomToken<TimelineToken<any>[]>;
  timelineSelectors: ReadonlyPureSelectorFamilyToken<Timeline<any>, string>;
  typeSelectors: ReadonlyPureSelectorFamilyToken<Loadable<string>, string>;
};
declare const attachIntrospectionStates: (store: RootStore) => IntrospectionStates;
//#endregion
//#region src/introspection/auditor.d.ts
type ListResourcesParam = {
  atomFamilies: boolean;
  selectorFamilies: boolean;
};
/**
 * Auditor is a tool for identifying lingering resources in your store that may result in memory leaks.
 * @experimental
 */
declare class Auditor {
  readonly store: Store;
  auditorCreatedAt: number;
  statesCreatedAt: Map<string, number>;
  readonly atomIndex: AtomToken<AtomTokenIndex>;
  readonly selectorIndex: AtomToken<SelectorTokenIndex>;
  disposed: boolean;
  private readonly unsubscribeFromAtomCreation;
  private readonly unsubscribeFromAtomDisposal;
  private readonly unsubscribeFromSelectorCreation;
  private readonly unsubscribeFromSelectorDisposal;
  /**
   * @param {Store} store - The store to audit.
   */
  constructor(store?: Store);
  static readonly DEFAULT_LIST_RESOURCES_PARAM: ListResourcesParam;
  /**
   * Lists all resources in the store, along with their creation time.
   *
   * @param {ListResourcesParam} [param] - Optional parameters for filtering the list of resources.
   * @returns {readonly [ReadableToken<unknown>, number]}[] - An array of tuples, where each tuple contains a state token belonging to a family in the store and that state's creation time.
   */
  listResources(param?: ListResourcesParam): (readonly [ReadableToken<unknown>, number])[];
  [Symbol.dispose](): void;
}
//#endregion
//#region src/introspection/refinery.d.ts
type ClassSignature = abstract new (...args: any) => any;
type RefinementStrategy = ClassSignature | Refinement<unknown, any>;
type Supported<Refine extends RefinementStrategy> = Refine extends Refinement<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
type RefinementSupport = Record<string, RefinementStrategy>;
declare class Refinery<SupportedTypes extends RefinementSupport> {
  supported: SupportedTypes;
  constructor(supported: SupportedTypes);
  refine<T>(input: T): Flat<{ [K in keyof SupportedTypes]: T extends Supported<SupportedTypes[K]> ? {
    type: K;
    data: Supported<SupportedTypes[K]>;
  } : Supported<SupportedTypes[K]> extends T ? {
    type: K;
    data: Supported<SupportedTypes[K]>;
  } : never; }>[keyof SupportedTypes] | (T extends Supported<SupportedTypes[keyof SupportedTypes]> ? never : null);
}
declare const primitiveRefinery: Refinery<{
  number: (input: unknown) => input is number;
  string: (input: unknown) => input is string;
  boolean: (input: unknown) => input is boolean;
  null: (input: unknown) => input is null;
}>;
declare function isPlainObject(input: unknown): input is Json.Tree.Object;
declare const jsonTreeRefinery: Refinery<{
  object: (input: unknown) => input is Json.Tree.Object;
  array: (input: unknown) => input is Json.Tree.Array;
}>;
declare const jsonRefinery: Refinery<{
  object: (input: unknown) => input is Json.Tree.Object;
  array: (input: unknown) => input is Json.Tree.Array;
  number: (input: unknown) => input is number;
  string: (input: unknown) => input is string;
  boolean: (input: unknown) => input is boolean;
  null: (input: unknown) => input is null;
}>;
type JsonType = keyof typeof jsonRefinery.supported;
declare const discoverType: (input: unknown) => JsonType | `Map` | `Set` | `undefined` | (string & {});
//#endregion
//#region src/introspection/differ.d.ts
declare function diffNumber(a: number, b: number): Delta;
declare function diffString(a: string, b: string): Delta;
declare function diffBoolean(a: boolean, b: boolean): Delta;
declare function diffObject(a: Json.Tree.Object, b: Json.Tree.Object, recurse: Diff<unknown>): Delta;
declare function diffArray(a: Json.Tree.Array, b: Json.Tree.Array, recurse: Diff<unknown>): Delta;
type Delta = {
  summary: string;
  added?: [path: string, addedStringifiedValue: string][];
  removed?: [path: string, removedStringifiedValue: string][];
  changed?: [path: string, delta: Delta][];
};
type Diff<T> = (a: T, b: T) => Delta;
type DiffTree<T> = (a: T, b: T, recurse: Differ<any, any>[`diff`]) => Delta;
declare class Differ<Leaf extends Record<string, any>, Tree extends Record<string, any>> {
  leafRefinery: Refinery<Leaf>;
  treeRefinery: Refinery<Tree>;
  leafDiffers: { [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>; };
  treeDiffers: { [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>; };
  constructor(leafRefinery: Refinery<Leaf>, treeRefinery: Refinery<Tree>, diffFunctions: { [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>; } & { [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>; });
  diff(a: unknown, b: unknown): Delta;
}
declare const prettyJson: Differ<{
  number: (input: unknown) => input is number;
  string: (input: unknown) => input is string;
  boolean: (input: unknown) => input is boolean;
  null: (input: unknown) => input is null;
}, {
  object: (input: unknown) => input is Json.Tree.Object;
  array: (input: unknown) => input is Json.Tree.Array;
}>;
//#endregion
//#region src/introspection/sprawl.d.ts
type InspectionResult = Partial<{
  pathComplete: true;
  jobComplete: true;
}>;
type InspectNode = (path: string[], node: unknown) => InspectionResult | void;
declare const sprawl: (tree: Array<unknown> | object, inspector: InspectNode) => void;
//#endregion
//#region src/introspection/index.d.ts
type FamilyNode<Token extends ReadableToken<unknown, any, any>> = {
  key: string;
  familyMembers: Map<string, Token>;
};
type ReadonlyTokenIndex<Token extends ReadableToken<unknown, any, any>> = ReadonlyMap<string, FamilyNode<Token> | Token>;
type WritableTokenIndex<Token extends ReadableToken<unknown, any, any>> = Map<string, FamilyNode<Token> | Token>;
//#endregion
export { Auditor, ClassSignature, Differ, FamilyNode, InspectNode, InspectionResult, IntrospectionStates, JsonType, ListResourcesParam, ReadonlyTokenIndex, RefinementStrategy, RefinementSupport, Refinery, Supported, WritableTokenIndex, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl };
//# sourceMappingURL=index.d.ts.map