twokeys 2.0.1 → 2.2.0

package/dist/index.d.cts

@@ -1,3 +1,472 @@
+type GraphNodeInput<NodeId extends string = string> = NodeId | {
+    id: NodeId;
+};
+interface GraphEdge<NodeId extends string = string> {
+    from: NodeId;
+    to: NodeId;
+    weight?: number;
+}
+interface GraphBuildOptions {
+    directed?: boolean;
+}
+interface GraphNeighbor<NodeId extends string = string> {
+    id: NodeId;
+    weight: number;
+}
+interface GraphAdjacency<NodeId extends string = string> {
+    nodes: NodeId[];
+    neighborsByNode: Map<NodeId, GraphNeighbor<NodeId>[]>;
+    incomingByNode: Map<NodeId, GraphNeighbor<NodeId>[]>;
+    edges: Array<Required<GraphEdge<NodeId>>>;
+    directed: boolean;
+}
+type GraphAlgorithmErrorCode = 'NEGATIVE_WEIGHT' | 'NEGATIVE_CYCLE' | 'INVALID_ARGUMENT';
+declare class GraphAlgorithmError extends Error {
+    readonly code: GraphAlgorithmErrorCode;
+    constructor(code: GraphAlgorithmErrorCode, message: string);
+}
+interface TopologicalSortOptions<NodeId extends string = string> {
+    tieBreaker?: (left: NodeId, right: NodeId) => number;
+    priority?: (nodeId: NodeId) => number;
+    priorityByNode?: Map<NodeId, number> | Partial<Record<NodeId, number>>;
+}
+interface TopologicalSortResult<NodeId extends string = string> {
+    order: NodeId[];
+    cycleNodes: NodeId[];
+    isDag: boolean;
+}
+interface StronglyConnectedComponentsOptions extends GraphBuildOptions {
+}
+interface StronglyConnectedComponentsResult<NodeId extends string = string> {
+    components: NodeId[][];
+    componentByNode: Map<NodeId, number>;
+}
+interface WeaklyConnectedComponentsResult<NodeId extends string = string> {
+    components: NodeId[][];
+    componentByNode: Map<NodeId, number>;
+}
+interface DegreeCentralityRecord {
+    inDegree: number;
+    outDegree: number;
+    degree: number;
+    normalized: number;
+}
+type ClosenessCentralityMode = 'classic' | 'harmonic';
+interface ClosenessCentralityRecord {
+    reachableCount: number;
+    distanceSum: number;
+    score: number;
+    normalized: number;
+    mode: ClosenessCentralityMode;
+    negativeCycle: boolean;
+}
+interface BetweennessCentralityRecord {
+    raw: number;
+    normalized: number;
+}
+interface PageRankOptions extends GraphBuildOptions {
+    dampingFactor?: number;
+    tolerance?: number;
+    maxIterations?: number;
+}
+interface PageRankRecord {
+    score: number;
+    normalized: number;
+    rank: number;
+}
+interface PageRankResult<NodeId extends string = string> {
+    byNode: Map<NodeId, PageRankRecord>;
+    order: NodeId[];
+    iterations: number;
+    converged: boolean;
+    dampingFactor: number;
+}
+interface MinimumSpanningTreeOptions<NodeId extends string = string> {
+    tieBreaker?: (left: NodeId, right: NodeId) => number;
+}
+interface MinimumSpanningTreeResult<NodeId extends string = string> {
+    edges: Array<Required<GraphEdge<NodeId>>>;
+    totalWeight: number;
+    componentCount: number;
+    spanning: boolean;
+}
+interface ArticulationBridgeResult<NodeId extends string = string> {
+    articulationPoints: NodeId[];
+    bridges: Array<Required<GraphEdge<NodeId>>>;
+}
+interface GraphAnalysisResult<NodeId extends string = string> {
+    degree: Map<NodeId, DegreeCentralityRecord>;
+    closeness: Map<NodeId, ClosenessCentralityRecord>;
+    betweenness: Map<NodeId, BetweennessCentralityRecord>;
+    pageRank: Map<NodeId, PageRankRecord>;
+    stronglyConnectedComponents: NodeId[][];
+    weaklyConnectedComponents: NodeId[][];
+    articulationPoints: NodeId[];
+    bridges: Array<Required<GraphEdge<NodeId>>>;
+}
+interface GraphAnalysisOptions extends GraphBuildOptions {
+    closenessMode?: ClosenessCentralityMode;
+    shortestPathAlgorithm?: ShortestPathAlgorithm;
+    pageRankOptions?: Omit<PageRankOptions, 'directed'>;
+}
+type ShortestPathAlgorithm = 'auto' | 'dijkstra' | 'bellman-ford';
+interface ShortestPathOptions extends GraphBuildOptions {
+    algorithm?: ShortestPathAlgorithm;
+    failOnNegativeCycle?: boolean;
+}
+interface ShortestPathResult<NodeId extends string = string> {
+    source: NodeId;
+    target: NodeId;
+    path: NodeId[];
+    distance: number;
+    reachable: boolean;
+    explored: number;
+    algorithm: ShortestPathAlgorithm;
+    hasNegativeWeights: boolean;
+    negativeCycle: boolean;
+}
+interface LabelPropagationOptions<NodeId extends string = string> extends GraphBuildOptions {
+    maxIterations?: number;
+    tieBreaker?: (left: NodeId, right: NodeId) => number;
+}
+interface LouvainOptions<NodeId extends string = string> extends GraphBuildOptions {
+    maxPasses?: number;
+    tolerance?: number;
+    tieBreaker?: (left: NodeId, right: NodeId) => number;
+}
+interface CommunityDetectionResult<NodeId extends string = string> {
+    communities: NodeId[][];
+    communityByNode: Map<NodeId, number>;
+    iterations: number;
+    converged: boolean;
+    algorithm: 'label-propagation' | 'louvain';
+    modularity: number;
+}
+type SimilarityMetric = 'common-neighbors' | 'jaccard' | 'cosine' | 'overlap' | 'adamic-adar' | 'resource-allocation' | 'preferential-attachment';
+interface SimilarityOptions extends GraphBuildOptions {
+    metric?: SimilarityMetric;
+    minScore?: number;
+}
+interface NodeSimilarityRecord<NodeId extends string = string> {
+    left: NodeId;
+    right: NodeId;
+    score: number;
+    metric: SimilarityMetric;
+    rank: number;
+}
+interface NodeSimilarityResult<NodeId extends string = string> {
+    metric: SimilarityMetric;
+    pairs: NodeSimilarityRecord<NodeId>[];
+}
+interface KNearestNeighborsOptions extends GraphBuildOptions {
+    metric?: SimilarityMetric;
+    k?: number;
+    minScore?: number;
+}
+interface KNearestNeighbor<NodeId extends string = string> {
+    nodeId: NodeId;
+    score: number;
+}
+interface KNearestNeighborsResult<NodeId extends string = string> {
+    metric: SimilarityMetric;
+    k: number;
+    neighborsByNode: Map<NodeId, KNearestNeighbor<NodeId>[]>;
+}
+interface LinkPredictionOptions<NodeId extends string = string> extends GraphBuildOptions {
+    metric?: SimilarityMetric;
+    limit?: number;
+    minScore?: number;
+    allowExistingEdges?: boolean;
+    sourceFilter?: NodeId[];
+    targetFilter?: NodeId[];
+}
+interface LinkPredictionRecord<NodeId extends string = string> {
+    from: NodeId;
+    to: NodeId;
+    score: number;
+    metric: SimilarityMetric;
+    rank: number;
+}
+interface LinkPredictionResult<NodeId extends string = string> {
+    metric: SimilarityMetric;
+    predictions: LinkPredictionRecord<NodeId>[];
+}
+interface AStarOptions<NodeId extends string = string> extends GraphBuildOptions {
+    heuristic?: (nodeId: NodeId, targetId: NodeId) => number;
+}
+interface AStarResult<NodeId extends string = string> {
+    source: NodeId;
+    target: NodeId;
+    path: NodeId[];
+    distance: number;
+    reachable: boolean;
+    explored: number;
+    estimatedDistance: number;
+}
+interface PathRecord<NodeId extends string = string> {
+    path: NodeId[];
+    distance: number;
+}
+interface YenKShortestPathsOptions extends GraphBuildOptions {
+    k?: number;
+    shortestPathAlgorithm?: ShortestPathAlgorithm;
+}
+interface YenKShortestPathsResult<NodeId extends string = string> {
+    source: NodeId;
+    target: NodeId;
+    paths: PathRecord<NodeId>[];
+    complete: boolean;
+}
+interface AllPairsShortestPathsOptions extends GraphBuildOptions {
+    algorithm?: ShortestPathAlgorithm;
+    failOnNegativeCycle?: boolean;
+}
+interface AllPairsShortestPathsResult<NodeId extends string = string> {
+    nodes: NodeId[];
+    distanceBySource: Map<NodeId, Map<NodeId, number>>;
+    previousBySource: Map<NodeId, Map<NodeId, NodeId>>;
+    algorithm: ShortestPathAlgorithm;
+    hasNegativeWeights: boolean;
+    negativeCycle: boolean;
+}
+interface FlowEdge<NodeId extends string = string> {
+    from: NodeId;
+    to: NodeId;
+    capacity: number;
+    cost?: number;
+}
+interface FlowEdgeResult<NodeId extends string = string> {
+    from: NodeId;
+    to: NodeId;
+    flow: number;
+    capacity: number;
+}
+interface MaximumFlowOptions extends GraphBuildOptions {
+}
+interface MaximumFlowResult<NodeId extends string = string> {
+    source: NodeId;
+    sink: NodeId;
+    maxFlow: number;
+    augmentations: number;
+    flowByEdge: FlowEdgeResult<NodeId>[];
+    sourcePartition: NodeId[];
+    sinkPartition: NodeId[];
+    cutEdges: Array<Required<GraphEdge<NodeId>>>;
+}
+interface MinCostMaxFlowOptions extends GraphBuildOptions {
+    targetFlow?: number;
+}
+interface MinCostFlowEdgeResult<NodeId extends string = string> extends FlowEdgeResult<NodeId> {
+    cost: number;
+}
+interface MinCostMaxFlowResult<NodeId extends string = string> {
+    source: NodeId;
+    sink: NodeId;
+    flow: number;
+    cost: number;
+    complete: boolean;
+    augmentations: number;
+    flowByEdge: MinCostFlowEdgeResult<NodeId>[];
+}
+type KMeansNormalization = 'none' | 'zscore' | 'minmax';
+interface KMeansOptions {
+    maxIterations?: number;
+    tolerance?: number;
+    seed?: number;
+    nInit?: number;
+    normalization?: KMeansNormalization;
+    useKMeansPlusPlus?: boolean;
+}
+interface KMeansCluster {
+    centroid: number[];
+    indices: number[];
+}
+interface KMeansResult {
+    assignments: number[];
+    clusters: KMeansCluster[];
+    iterations: number;
+    inertia: number;
+    converged: boolean;
+    silhouette: number | null;
+    selectedSeed: number;
+}
+interface KMeansAutoOptions extends KMeansOptions {
+    kMin?: number;
+    kMax?: number;
+}
+interface KMeansAutoCandidate {
+    k: number;
+    silhouette: number | null;
+    inertia: number;
+}
+interface KMeansAutoResult extends KMeansResult {
+    selectedK: number;
+    candidates: KMeansAutoCandidate[];
+}
+interface TravelingSalesmanOptions<NodeId extends string = string> extends GraphBuildOptions {
+    start?: NodeId;
+    returnToStart?: boolean;
+    twoOptPasses?: number;
+    multiStartCount?: number;
+    startCandidates?: NodeId[];
+    seed?: number;
+    shortestPathAlgorithm?: ShortestPathAlgorithm;
+}
+interface TravelingSalesmanSegment<NodeId extends string = string> {
+    from: NodeId;
+    to: NodeId;
+    distance: number;
+    path: NodeId[];
+}
+interface TravelingSalesmanResult<NodeId extends string = string> {
+    order: NodeId[];
+    distance: number;
+    segments: TravelingSalesmanSegment<NodeId>[];
+    visitedCount: number;
+    complete: boolean;
+    unreachableNodes: NodeId[];
+    lowerBound: number;
+    optimalityGap: number | null;
+}
+declare function buildGraphAdjacency<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: GraphBuildOptions): GraphAdjacency<NodeId>;
+declare function stronglyConnectedComponents<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: StronglyConnectedComponentsOptions): StronglyConnectedComponentsResult<NodeId>;
+declare function weaklyConnectedComponents<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[]): WeaklyConnectedComponentsResult<NodeId>;
+declare function topologicalSort<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: TopologicalSortOptions<NodeId>): TopologicalSortResult<NodeId>;
+declare function degreeCentrality<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: GraphBuildOptions): Map<NodeId, DegreeCentralityRecord>;
+interface ClosenessCentralityOptions extends GraphBuildOptions {
+    mode?: ClosenessCentralityMode;
+    shortestPathAlgorithm?: ShortestPathAlgorithm;
+}
+declare function closenessCentrality<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: ClosenessCentralityOptions): Map<NodeId, ClosenessCentralityRecord>;
+declare function betweennessCentrality<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: GraphBuildOptions): Map<NodeId, BetweennessCentralityRecord>;
+declare function pageRank<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: PageRankOptions): PageRankResult<NodeId>;
+declare function minimumSpanningTree<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: MinimumSpanningTreeOptions<NodeId>): MinimumSpanningTreeResult<NodeId>;
+declare function articulationPointsAndBridges<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[]): ArticulationBridgeResult<NodeId>;
+declare function analyzeGraph<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: GraphAnalysisOptions): GraphAnalysisResult<NodeId>;
+declare function shortestPath<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], source: NodeId, target: NodeId, options?: ShortestPathOptions): ShortestPathResult<NodeId>;
+declare function labelPropagationCommunities<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: LabelPropagationOptions<NodeId>): CommunityDetectionResult<NodeId>;
+declare function louvainCommunities<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: LouvainOptions<NodeId>): CommunityDetectionResult<NodeId>;
+declare function nodeSimilarity<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: SimilarityOptions): NodeSimilarityResult<NodeId>;
+declare function kNearestNeighbors<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: KNearestNeighborsOptions): KNearestNeighborsResult<NodeId>;
+declare function predictLinks<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: LinkPredictionOptions<NodeId>): LinkPredictionResult<NodeId>;
+declare function linkPrediction<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: LinkPredictionOptions<NodeId>): LinkPredictionResult<NodeId>;
+declare function aStarShortestPath<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], source: NodeId, target: NodeId, options?: AStarOptions<NodeId>): AStarResult<NodeId>;
+declare function allPairsShortestPaths<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: AllPairsShortestPathsOptions): AllPairsShortestPathsResult<NodeId>;
+declare function yenKShortestPaths<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], source: NodeId, target: NodeId, options?: YenKShortestPathsOptions): YenKShortestPathsResult<NodeId>;
+declare function maximumFlow<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], source: NodeId, sink: NodeId, options?: MaximumFlowOptions): MaximumFlowResult<NodeId>;
+declare function minCostMaxFlow<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: FlowEdge<NodeId>[], source: NodeId, sink: NodeId, options?: MinCostMaxFlowOptions): MinCostMaxFlowResult<NodeId>;
+declare function kMeansClustering(points: number[][], k: number, options?: KMeansOptions): KMeansResult;
+declare function kMeansAuto(points: number[][], options?: KMeansAutoOptions): KMeansAutoResult;
+declare function travelingSalesmanApprox<NodeId extends string>(nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: TravelingSalesmanOptions<NodeId>): TravelingSalesmanResult<NodeId>;
+
+interface GdsProjectOptions {
+    directed?: boolean;
+    replace?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface GdsGraphProjection<NodeId extends string = string> {
+    name: string;
+    nodes: NodeId[];
+    edges: Array<Required<GraphEdge<NodeId>>>;
+    directed: boolean;
+    createdAt: number;
+    metadata: Record<string, unknown>;
+}
+interface GdsCatalogEntry {
+    name: string;
+    nodeCount: number;
+    edgeCount: number;
+    directed: boolean;
+    createdAt: number;
+    metadata: Record<string, unknown>;
+}
+type GdsPipelineStep<NodeId extends string = string> = {
+    id: string;
+    kind: 'page-rank';
+    options?: PageRankOptions;
+} | {
+    id: string;
+    kind: 'louvain';
+    options?: LouvainOptions<NodeId>;
+} | {
+    id: string;
+    kind: 'label-propagation';
+    options?: LabelPropagationOptions<NodeId>;
+} | {
+    id: string;
+    kind: 'similarity';
+    options?: SimilarityOptions;
+} | {
+    id: string;
+    kind: 'knn';
+    options?: KNearestNeighborsOptions;
+} | {
+    id: string;
+    kind: 'link-prediction';
+    options?: LinkPredictionOptions<NodeId>;
+} | {
+    id: string;
+    kind: 'shortest-path';
+    source: NodeId;
+    target: NodeId;
+    options?: ShortestPathOptions;
+} | {
+    id: string;
+    kind: 'a-star';
+    source: NodeId;
+    target: NodeId;
+    options?: AStarOptions<NodeId>;
+} | {
+    id: string;
+    kind: 'yen-k-shortest-paths';
+    source: NodeId;
+    target: NodeId;
+    options?: YenKShortestPathsOptions;
+} | {
+    id: string;
+    kind: 'max-flow';
+    source: NodeId;
+    sink: NodeId;
+    options?: MaximumFlowOptions;
+} | {
+    id: string;
+    kind: 'min-cost-max-flow';
+    source: NodeId;
+    sink: NodeId;
+    edges?: FlowEdge<NodeId>[] | null;
+    options?: MinCostMaxFlowOptions;
+} | {
+    id: string;
+    kind: 'all-pairs-shortest-paths';
+    options?: AllPairsShortestPathsOptions;
+};
+type GdsPipelineOutput<NodeId extends string = string> = PageRankResult<NodeId> | CommunityDetectionResult<NodeId> | NodeSimilarityResult<NodeId> | KNearestNeighborsResult<NodeId> | LinkPredictionResult<NodeId> | ShortestPathResult<NodeId> | AStarResult<NodeId> | YenKShortestPathsResult<NodeId> | MaximumFlowResult<NodeId> | MinCostMaxFlowResult<NodeId> | AllPairsShortestPathsResult<NodeId>;
+declare class GraphCatalog<NodeId extends string = string> {
+    private projections;
+    project(name: string, nodes: GraphNodeInput<NodeId>[], edges: GraphEdge<NodeId>[], options?: GdsProjectOptions): GdsGraphProjection<NodeId>;
+    drop(name: string): boolean;
+    clear(): void;
+    exists(name: string): boolean;
+    get(name: string): GdsGraphProjection<NodeId> | null;
+    list(): GdsCatalogEntry[];
+    pageRank(name: string, options?: PageRankOptions): PageRankResult<NodeId>;
+    louvain(name: string, options?: LouvainOptions<NodeId>): CommunityDetectionResult<NodeId>;
+    labelPropagation(name: string, options?: LabelPropagationOptions<NodeId>): CommunityDetectionResult<NodeId>;
+    similarity(name: string, options?: SimilarityOptions): NodeSimilarityResult<NodeId>;
+    knn(name: string, options?: KNearestNeighborsOptions): KNearestNeighborsResult<NodeId>;
+    linkPrediction(name: string, options?: LinkPredictionOptions<NodeId>): LinkPredictionResult<NodeId>;
+    shortestPath(name: string, source: NodeId, target: NodeId, options?: ShortestPathOptions): ShortestPathResult<NodeId>;
+    aStar(name: string, source: NodeId, target: NodeId, options?: AStarOptions<NodeId>): AStarResult<NodeId>;
+    yen(name: string, source: NodeId, target: NodeId, options?: YenKShortestPathsOptions): YenKShortestPathsResult<NodeId>;
+    allPairs(name: string, options?: AllPairsShortestPathsOptions): AllPairsShortestPathsResult<NodeId>;
+    maxFlow(name: string, source: NodeId, sink: NodeId, options?: MaximumFlowOptions): MaximumFlowResult<NodeId>;
+    minCostMaxFlow(name: string, source: NodeId, sink: NodeId, edges?: FlowEdge<NodeId>[] | null, options?: MinCostMaxFlowOptions): MinCostMaxFlowResult<NodeId>;
+    runPipeline(name: string, steps: GdsPipelineStep<NodeId>[]): Map<string, GdsPipelineOutput<NodeId>>;
+    private requireProjection;
+}
+declare function createGraphCatalog<NodeId extends string = string>(): GraphCatalog<NodeId>;
+declare const gds: GraphCatalog<string>;
+
 /**
  * Twokeys - A small data exploration and manipulation library
  * Named after John Tukey, pioneer of exploratory data analysis (EDA)
@@ -190,4 +659,4 @@ declare class Twokeys {
     static randomPoints: typeof randomPoints;
 }
 
-export { type BinnedResult, type MedianResult, type ModeResult, Points, type PointsDescription, type PointsOptions, type RankInfo, type RankedResult, Series, type SeriesDescription, type SeriesOptions, Twokeys, Twokeys as default };
+export { type AStarOptions, type AStarResult, type AllPairsShortestPathsOptions, type AllPairsShortestPathsResult, type ArticulationBridgeResult, type BetweennessCentralityRecord, type BinnedResult, type ClosenessCentralityMode, type ClosenessCentralityOptions, type ClosenessCentralityRecord, type CommunityDetectionResult, type DegreeCentralityRecord, type FlowEdge, type FlowEdgeResult, type GdsCatalogEntry, type GdsGraphProjection, type GdsPipelineOutput, type GdsPipelineStep, type GdsProjectOptions, type GraphAdjacency, GraphAlgorithmError, type GraphAlgorithmErrorCode, type GraphAnalysisOptions, type GraphAnalysisResult, type GraphBuildOptions, GraphCatalog, type GraphEdge, type GraphNeighbor, type GraphNodeInput, type KMeansAutoCandidate, type KMeansAutoOptions, type KMeansAutoResult, type KMeansCluster, type KMeansNormalization, type KMeansOptions, type KMeansResult, type KNearestNeighbor, type KNearestNeighborsOptions, type KNearestNeighborsResult, type LabelPropagationOptions, type LinkPredictionOptions, type LinkPredictionRecord, type LinkPredictionResult, type LouvainOptions, type MaximumFlowOptions, type MaximumFlowResult, type MedianResult, type MinCostFlowEdgeResult, type MinCostMaxFlowOptions, type MinCostMaxFlowResult, type MinimumSpanningTreeOptions, type MinimumSpanningTreeResult, type ModeResult, type NodeSimilarityRecord, type NodeSimilarityResult, type PageRankOptions, type PageRankRecord, type PageRankResult, type PathRecord, Points, type PointsDescription, type PointsOptions, type RankInfo, type RankedResult, Series, type SeriesDescription, type SeriesOptions, type ShortestPathAlgorithm, type ShortestPathOptions, type ShortestPathResult, type SimilarityMetric, type SimilarityOptions, type StronglyConnectedComponentsOptions, type StronglyConnectedComponentsResult, type TopologicalSortOptions, type TopologicalSortResult, type TravelingSalesmanOptions, type TravelingSalesmanResult, type TravelingSalesmanSegment, Twokeys, type WeaklyConnectedComponentsResult, type YenKShortestPathsOptions, type YenKShortestPathsResult, aStarShortestPath, allPairsShortestPaths, analyzeGraph, articulationPointsAndBridges, betweennessCentrality, buildGraphAdjacency, closenessCentrality, createGraphCatalog, Twokeys as default, degreeCentrality, gds, kMeansAuto, kMeansClustering, kNearestNeighbors, labelPropagationCommunities, linkPrediction, louvainCommunities, maximumFlow, minCostMaxFlow, minimumSpanningTree, nodeSimilarity, pageRank, predictLinks, shortestPath, stronglyConnectedComponents, topologicalSort, travelingSalesmanApprox, weaklyConnectedComponents, yenKShortestPaths };