import type { EntityProperty } from '../typings.js';
export declare const enum NodeState {
  NOT_VISITED = 0,
  IN_PROGRESS = 1,
  VISITED = 2,
}
type Hash = number;
export interface Node {
  hash: Hash;
  state: NodeState;
  dependencies: Map<Hash, Edge>;
}
export interface Edge {
  from: Hash;
  to: Hash;
  weight: number;
}
/**
 * CommitOrderCalculator implements topological sorting, which is an ordering
 * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
 * using a depth-first searching (DFS) to traverse the graph built in memory.
 * This algorithm have a linear running time based on nodes (V) and dependency
 * between the nodes (E), resulting in a computational complexity of O(V + E).
 *
 * Based on https://github.com/doctrine/orm/blob/master/lib/Doctrine/ORM/Internal/CommitOrderCalculator.php
 * @internal
 */
export declare class CommitOrderCalculator {
  #private;
  /**
   * Checks for node existence in graph.
   */
  hasNode(hash: Hash): boolean;
  /**
   * Adds a new node to the graph, assigning its hash.
   */
  addNode(hash: Hash): void;
  /**
   * Adds a new dependency (edge) to the graph using their hashes.
   */
  addDependency(from: Hash, to: Hash, weight: number): void;
  discoverProperty(prop: EntityProperty, entityName: Hash): void;
  /**
   * Return a valid order list of all current nodes.
   * The desired topological sorting is the reverse post order of these searches.
   *
   * @internal Highly performance-sensitive method.
   */
  sort(): Hash[];
  /**
   * Visit a given node definition for reordering.
   *
   * @internal Highly performance-sensitive method.
   */
  private visit;
  /**
   * Visits all target's dependencies if in cycle with given node
   */
  private visitOpenNode;
}
export {};
