/// <reference lib="dom" />
import { ApiEdge } from "./apiEdge";
import { ApiNode } from "./apiNode";
import { areGraphSnapshotsEqual, AreGraphSnapshotsEqualOptions } from "./areGraphSnapshotsEqual";
import { flyToCenter } from "./camera/flyToCenter";
import { flyToPosition, TweenPositionOptions } from "./camera/flyToPosition";
import { CameraOptions, setCameraOptions } from "./camera/setCameraOptions";
import { CategoryConfig, CategoryId } from "./category";
import { betweenness, BetweennessResult } from "./centrality/betweenness";
import { closeness, ClosenessResult } from "./centrality/closeness";
import { pageRank, PageRankOptions, PageRankResult } from "./centrality/pageRank";
import { collectNodes, CollectNodesOptions } from "./collection-node/collectNodes";
import { explodeCollections, ExplodeCollectionsOptions } from "./collection-node/explodeCollections";
import { makeCollectionNode } from "./collection-node/makeCollectionNode";
import { NodeCollection } from "./collection-node/nodeCollection";
import { uncollectNodes, UncollectNodesOptions } from "./collection-node/uncollectNodes";
import { colorNodesByProperty, ColorNodesByPropertyOptions } from "./colorNodesByProperty";
import { connectedComponent, ConnectedComponentResult } from "./community-detection/connectedComponent";
import { louvain, LouvainResult } from "./community-detection/louvain";
import { stronglyConnectedComponent } from "./community-detection/stronglyConnectedComponent";
import { convertToScreenCoordinates } from "./convertToScreenCoordinates";
import { dispatchGraphDataUpdate } from "./dispatchGraphDataUpdate";
import { edgesByRelationship } from "./edgesByRelationship";
import { EdgeFilter, NodeFilter } from "./filter/filter";
import { nodesByCategory } from "./filter/nodesByCategory";
import { getCategoryColor } from "./getCategoryColor";
import { getCategoryConfig } from "./getCategoryConfig";
import { getLayoutGraph } from "./getLayoutGraph";
import { NodeFilterOptions } from "./getNodesWithOptions";
import { getObservableLayoutGraph, ObservableLayoutGraph } from "./getObservableLayoutGraph";
import { getScene } from "./getScene";
import { GraphSnapshot } from "./graphSnapshot";
import { alignBy, AlignByOptions } from "./layout/alignBy";
import { applyLayout } from "./layout/applyLayout";
import { distributionBy, DistributionOptions } from "./layout/distributionBy";
import { ego, EgoOptions } from "./layout/ego";
import { layout, LayoutFunction, LayoutNodesFunction, NodeIdToPosition } from "./layout/layout";
import { ParametricOptions } from "./layout/parametric";
import { RotateOptions } from "./layout/rotate";
import { scale, ScaleOptions } from "./layout/scale";
import { AxesOptions, setParametricAxesOptions } from "./layout/setParametricAxesOptions";
import { shift, ShiftOptions } from "./layout/shift";
import { TweenLayoutOverrides } from "./layout/tween/tweenLayout";
import { LayoutGraph } from "./layoutGraph";
import { LegacyLayoutGraph } from "./legacyLayoutGraph";
import { makeColor } from "./makeColor";
import { makeEdge } from "./makeEdge";
import { makeGraph } from "./makeGraph";
import { makeNode } from "./makeNode";
import { makeNodeId } from "./makeNodeId";
import { makePosition } from "./makePosition";
import { makeRandomGraph, MakeRandomGraphOptions } from "./makeRandomGraph";
import { makeRandomPosition } from "./makeRandomPosition";
import { MapPolyfill } from "./mapPolyfill";
import { expandNodes, ExpandNodesEdgeDirection, ExpandNodesOptions, ExpandNodesStatusCode } from "./neo4j/expandNodes";
import { neo4j, Neo4jOptions, Neo4jQuery } from "./neo4j/neo4j";
import { NodeId } from "./node";
import { observe, ObserveCallback } from "./observe";
import { GraphxrEvent, GraphxrEventCallback, GraphxrEventCallbackId, on } from "./on";
import { DijkstraEdge, shortestPath, ShortestPathOptions } from "./path-finding/shortestPath";
import { traceNeighbors, TraceNeighborsOptions } from "./path-finding/traceNeighbors";
import { PropertyValue } from "./properties";
import { RelationshipId } from "./relationship";
import { getRuntime, Runtime, setRuntime } from "./runtime";
import { setAutoShowImage } from "./setAutoShowImage";
import { setCategoryCaptionProperties, SetCategoryCaptionPropertiesOptions } from "./setCategoryCaptionProperties";
import { setCategorySizeProperty, SetCategorySizePropertyOptions } from "./setCategorySizeProperty";
import { setEdgeScale } from "./setEdgeScale";
import { setFullscreen } from "./setFullscreen";
import { sleep } from "./sleep";
import { comparePropertyValues } from "./sort/comparePropertyValues";
import { Sort } from "./sort/sort";
import { sortByProperty, SortByPropertyOptions } from "./sort/sortByProperty";
import { Color, Dimension, Position } from "./styles";
import { aggregate, AggregateOptions } from "./transform/aggregate";
import { AggregateFormula } from "./transform/aggregateFormula";
import { createNodes, CreateNodesOptions } from "./transform/createNodes";
import { extract, ExtractOptions } from "./transform/extract";
import { link, LinkOptions } from "./transform/link";
import { map, MapFormula, MapOptions } from "./transform/map";
import { merge, MergeOptions } from "./transform/merge";
import { mergeNodes, MergeNodesOptions } from "./transform/mergeNodes";
import { mergeRelationships, MergeRelationshipsOptions } from "./transform/mergeRelationships";
import { shortcut, ShortcutOptions } from "./transform/shortcut";
import { TransformFunction } from "./transform/transform";
import { triggerForceLayout } from "./triggerForceLayout";
export * from "./apiEdge";
export * from "./apiLayoutGraph";
export * from "./apiNode";
export * from "./areGraphSnapshotsEqual";
export * from "./camera/flyToCenter";
export * from "./camera/flyToPosition";
export * from "./camera/setCameraOptions";
export * from "./camera/setCameraRotating";
export * from "./category";
export * from "./centrality/betweenness";
export * from "./centrality/closeness";
export * from "./centrality/pageRank";
export * from "./collection-node/collectNodes";
export * from "./collection-node/explodeCollections";
export * from './collection-node/makeCollectionNode';
export * from "./collection-node/uncollectNodes";
export * from "./colorNodesByProperty";
export * from "./community-detection/connectedComponent";
export * from "./community-detection/louvain";
export * from "./community-detection/stronglyConnectedComponent";
export * from "./dispatchGraphDataUpdate";
export * from "./edge";
export * from "./edgesByRelationship";
export * from "./filter/filter";
export * from "./filter/nodesByCategory";
export * from "./getCategoryColor";
export * from "./getCategoryConfig";
export * from "./getLayoutGraph";
export { NodeFilterOptions } from "./getNodesWithOptions";
export * from "./getObservableLayoutGraph";
export * from "./getScene";
export * from "./layout/alignBy";
export * from "./layout/applyLayout";
export * from "./layout/circle";
export * from "./layout/cube";
export * from "./layout/distributionBy";
export * from "./layout/ego";
export * from "./layout/grid";
export * from "./layout/layout";
export * from "./layout/line";
export * from "./layout/parametric";
export * from "./layout/random";
export * from "./layout/rotate";
export * from "./layout/scale";
export * from "./layout/setParametricAxesOptions";
export * from "./layout/shift";
export * from "./layout/spiral";
export * from "./layoutGraph";
export * from "./legacyLayoutGraph";
export * from "./makeColor";
export * from "./makeEdge";
export * from "./makeGraph";
export * from "./makeNode";
export * from "./makeNodeId";
export * from "./makePosition";
export * from "./makeRandomGraph";
export * from "./makeRandomPosition";
export * from "./minimumRequirements";
export * from "./neo4j/expandNodes";
export * from "./neo4j/neo4j";
export * from "./neo4j/neo4jGraphDataToGraph";
export * from "./neo4j/neo4jResult";
export * from "./node";
export * from "./observe";
export * from "./on";
export * from "./onChange";
export * from "./path-finding/shortestPath";
export * from "./path-finding/traceNeighbors";
export * from "./properties";
export * from "./range";
export * from "./relationship";
export * from "./runtime";
export * from "./setAutoShowImage";
export * from "./setCategoryCaptionProperties";
export * from "./setCategorySizeProperty";
export * from "./setEdgeScale";
export * from "./setFullscreen";
export * from "./sleep";
export * from "./sort/comparePropertyValues";
export * from "./sort/sort";
export * from "./sort/sortByProperty";
export * from "./styles";
export * from "./transform/aggregate";
export * from "./transform/createNodes";
export * from "./transform/extract";
export * from "./transform/link";
export * from "./transform/map";
export * from "./transform/merge";
export * from "./transform/mergeNodes";
export * from "./transform/mergeRelationships";
export * from "./transform/shortcut";
export * from "./triggerForceLayout";
export { GRAPHXR_API_VERSION } from "./version";
export interface API {
    getRuntime(): Runtime;
    setRuntime(runtime: Runtime): void;
    _minimumGraphxrVersion: string;
    _version: string;
    convertToScreenCoordinates(position: Position): Position;
    flyToCenter(view?: LayoutGraph, nodeIds?: NodeId[], offset?: number, options?: TweenPositionOptions): Promise<Position>;
    flyToPosition(position: Position, offset?: number, options?: TweenPositionOptions): Promise<Position>;
    setCameraRotating(isRotating: boolean): void;
    setCameraOptions(options: CameraOptions): void;
    getCategoryColor(categoryId: CategoryId): Color;
    getCategoryConfig(categoryId: CategoryId): CategoryConfig;
    setCategoryCaptionProperties(options: SetCategoryCaptionPropertiesOptions): Promise<unknown>;
    setCategorySizeProperty(options: SetCategorySizePropertyOptions): Promise<unknown>;
    betweenness(graph: LayoutGraph): BetweennessResult;
    closeness(graph: LayoutGraph): ClosenessResult;
    pageRank(graph: LayoutGraph, options?: PageRankOptions): PageRankResult;
    collectNodes(options?: CollectNodesOptions): TransformFunction;
    explodeCollections(options?: ExplodeCollectionsOptions): TransformFunction;
    uncollectNodes(options?: UncollectNodesOptions): TransformFunction;
    makeCollectionNode(category: CategoryId, collection: NodeCollection): ApiNode;
    connectedComponent(graph: LayoutGraph): ConnectedComponentResult;
    louvain(graph: LayoutGraph): LouvainResult;
    stronglyConnectedComponent(graph: LayoutGraph): ConnectedComponentResult;
    observe<T>(event: GraphxrEvent, compute: ObserveCallback): Iterator<T>;
    onChange<T>(callback: ObserveCallback): Iterator<T>;
    on(event: GraphxrEvent, callback: GraphxrEventCallback): GraphxrEventCallbackId;
    nodesByCategory(category: CategoryId): NodeFilter;
    edgesByRelationship(relationship: RelationshipId): EdgeFilter;
    areGraphSnapshotsEqual(left: GraphSnapshot, right: GraphSnapshot, options?: Partial<AreGraphSnapshotsEqualOptions>): boolean;
    getGraphView(): void;
    getLayoutGraph(): LegacyLayoutGraph;
    makeGraph(): LayoutGraph;
    makeEdge(edge: Partial<ApiEdge>): ApiEdge;
    makeNodeId(): NodeId;
    makeNode(options?: Partial<ApiNode>): ApiNode;
    makeRandomGraph(options?: MakeRandomGraphOptions): LayoutGraph;
    createNodes(options?: CreateNodesOptions): TransformFunction;
    mergeNodes(options?: MergeNodesOptions): TransformFunction;
    mergeRelationships(options?: MergeRelationshipsOptions): TransformFunction;
    getObservableLayoutGraph(): ObservableLayoutGraph;
    alignBy(options: AlignByOptions): LayoutFunction;
    applyLayout(view: LayoutGraph, computeLayout: LayoutFunction, tweenOverrides?: TweenLayoutOverrides): Promise<NodeIdToPosition>;
    circle(options?: NodeFilterOptions): LayoutFunction;
    cube(options?: NodeFilterOptions): LayoutFunction;
    distributionBy(options: DistributionOptions): LayoutFunction;
    ego(options: EgoOptions): LayoutFunction;
    layout(computeLayout: LayoutNodesFunction, options?: NodeFilterOptions): LayoutFunction;
    grid(options?: NodeFilterOptions): LayoutFunction;
    line(options?: NodeFilterOptions): LayoutFunction;
    parametric(options?: ParametricOptions): LayoutFunction;
    random(options?: NodeFilterOptions): LayoutFunction;
    rotate(options: RotateOptions): LayoutFunction;
    scale(options?: ScaleOptions): LayoutFunction;
    setParametricAxesOptions(options: Partial<AxesOptions>): void;
    shift(options: ShiftOptions): LayoutFunction;
    spiral(options?: NodeFilterOptions): LayoutFunction;
    triggerForceLayout(): void;
    colorNodesByProperty(options: ColorNodesByPropertyOptions): void;
    shortestPath(graph: LayoutGraph, options: ShortestPathOptions): DijkstraEdge[] | null;
    traceNeighbors(view: LegacyLayoutGraph, rootId: NodeId, options?: TraceNeighborsOptions): MapPolyfill<NodeId, boolean>;
    ExpandNodesEdgeDirection: Record<keyof typeof ExpandNodesEdgeDirection, string>;
    ExpandNodesStatusCode: Record<keyof typeof ExpandNodesStatusCode, string>;
    expandNodes(options?: Omit<ExpandNodesOptions, "excludedEdgeIds">): Promise<ExpandNodesStatusCode>;
    neo4j(query: Neo4jQuery, options?: Neo4jOptions): void;
    setAutoShowImage(value: boolean): boolean;
    setEdgeScale(value: number): number;
    dispatchGraphDataUpdate(): void;
    getScene(): THREE.Group;
    comparePropertyValues(left: PropertyValue, right: PropertyValue, ascending?: boolean): number;
    sortByProperty(property: SortByPropertyOptions): Sort<ApiNode>;
    makeColor(hexOrR: number, g?: number, b?: number): Color;
    makePosition(xyz: Partial<Position>): Position;
    makeRandomPosition(): Position;
    DIMENSIONS: Record<Dimension, Dimension>;
    aggregate(options: AggregateOptions): TransformFunction;
    aggregateFormula: {
        concatenate: AggregateFormula;
        takeFirst: AggregateFormula;
        count: AggregateFormula;
        sum: AggregateFormula;
        average: AggregateFormula;
        range: AggregateFormula;
        max: AggregateFormula;
        min: AggregateFormula;
    };
    extract(options: ExtractOptions): TransformFunction;
    link(options: LinkOptions): TransformFunction;
    map(options: MapOptions): TransformFunction;
    mapFormula: {
        toNumber: MapFormula;
        toString: MapFormula;
        toDate: MapFormula;
        toWeek: MapFormula;
    };
    merge(options: MergeOptions): TransformFunction;
    shortcut(options: ShortcutOptions): TransformFunction;
    range(size: number): number[];
    sleep(ms: number): Promise<number>;
    setFullscreen(value: boolean): boolean;
}
/**
 * Perform a runtime check of the minimum required GraphXR and API version. If minimum requirements are met, return the API. Otherwise, throw an error.
 * @returns a Promise that resolves to the API
 * @category API
 * @since 0.0.1
 */
export declare const Api: {
    _version: string;
    _minimumGraphxrVersion: string;
    alignBy: typeof alignBy;
    aggregate: typeof aggregate;
    aggregateFormula: {
        concatenate: (values: any[]) => string | null;
        takeFirst: (values: any[]) => any;
        count: (values: any[]) => number;
        sum: (values: any[]) => number;
        average: (values: any[]) => number;
        range: (values: any[]) => string;
        max: (values: any[]) => number;
        min: (values: any[]) => number;
    };
    applyLayout: typeof applyLayout;
    areGraphSnapshotsEqual: typeof areGraphSnapshotsEqual;
    betweenness: typeof betweenness;
    closeness: typeof closeness;
    circle: (options?: NodeFilterOptions | undefined) => LayoutFunction;
    collectNodes: typeof collectNodes;
    colorNodesByProperty: typeof colorNodesByProperty;
    comparePropertyValues: typeof comparePropertyValues;
    connectedComponent: typeof connectedComponent;
    convertToScreenCoordinates: typeof convertToScreenCoordinates;
    createNodes: typeof createNodes;
    cube: (options?: NodeFilterOptions | undefined) => LayoutFunction;
    shortestPath: typeof shortestPath;
    DIMENSIONS: Record<"x" | "y" | "z", "x" | "y" | "z">;
    dispatchGraphDataUpdate: typeof dispatchGraphDataUpdate;
    distributionBy: typeof distributionBy;
    edgesByRelationship: typeof edgesByRelationship;
    ego: typeof ego;
    ExpandNodesEdgeDirection: typeof ExpandNodesEdgeDirection;
    ExpandNodesStatusCode: typeof ExpandNodesStatusCode;
    expandNodes: typeof expandNodes;
    explodeCollections: typeof explodeCollections;
    extract: typeof extract;
    flyToCenter: typeof flyToCenter;
    flyToPosition: typeof flyToPosition;
    getCategoryColor: typeof getCategoryColor;
    getCategoryConfig: typeof getCategoryConfig;
    getGraphView: () => void;
    getLayoutGraph: typeof getLayoutGraph;
    getObservableLayoutGraph: typeof getObservableLayoutGraph;
    getScene: typeof getScene;
    getRuntime: typeof getRuntime;
    grid: (options?: NodeFilterOptions | undefined) => LayoutFunction;
    layout: typeof layout;
    line: (options?: NodeFilterOptions | undefined) => LayoutFunction;
    link: typeof link;
    louvain: typeof louvain;
    makeColor: typeof makeColor;
    makeCollectionNode: typeof makeCollectionNode;
    makeEdge: typeof makeEdge;
    makeGraph: typeof makeGraph;
    makeNode: typeof makeNode;
    makeNodeId: typeof makeNodeId;
    makePosition: typeof makePosition;
    makeRandomPosition: typeof makeRandomPosition;
    map: typeof map;
    mapFormula: {
        toNumber: (value: any) => number;
        toString: (value: any) => string;
        toDate: (value: any) => string;
        toWeek: (value: any) => string;
    };
    merge: typeof merge;
    makeRandomGraph: typeof makeRandomGraph;
    mergeNodes: typeof mergeNodes;
    mergeRelationships: typeof mergeRelationships;
    neo4j: typeof neo4j;
    nodesByCategory: typeof nodesByCategory;
    observe: typeof observe;
    on: typeof on;
    onChange: <T>(cb: ObserveCallback) => Iterator<T, any, undefined>;
    pageRank: typeof pageRank;
    parametric: (options: ParametricOptions) => LayoutFunction;
    random: (options?: NodeFilterOptions | undefined) => LayoutFunction;
    range: (size: number) => number[];
    rotate: (options: RotateOptions) => LayoutFunction;
    scale: typeof scale;
    shift: typeof shift;
    shortcut: typeof shortcut;
    sleep: typeof sleep;
    setAutoShowImage: typeof setAutoShowImage;
    setCameraRotating: (rotating: boolean) => void;
    setCameraOptions: typeof setCameraOptions;
    setCategoryCaptionProperties: typeof setCategoryCaptionProperties;
    setCategorySizeProperty: typeof setCategorySizeProperty;
    setEdgeScale: typeof setEdgeScale;
    setFullscreen: typeof setFullscreen;
    setParametricAxesOptions: typeof setParametricAxesOptions;
    setRuntime: typeof setRuntime;
    sortByProperty: typeof sortByProperty;
    spiral: (options?: NodeFilterOptions | undefined) => LayoutFunction;
    stronglyConnectedComponent: typeof stronglyConnectedComponent;
    traceNeighbors: typeof traceNeighbors;
    triggerForceLayout: typeof triggerForceLayout;
    uncollectNodes: typeof uncollectNodes;
};
export type GetApiOptions = {
    graphXrVersion?: string;
    runtime?: Runtime;
};
export declare const getApi: ({ graphXrVersion, runtime }?: GetApiOptions) => Promise<API>;