export function quaternionToCameraDirection(quaternion: any): import("three").Vector3;
export function debounce(func: any, delay: any): (...args: any[]) => void;
export function createThreeMatrix(matrix: any): import("three").Matrix4;
export function modelItemToThreeGeometry(modelItem: any): import("three").BufferGeometry;
/**
 * Get Faces from Face Normals
 * Summary: Use face normals to detect if the face is relevant in our
 * shortest distance calculation.
 *
 * Detail: The first iteration of improving shortest distance
 * calculation. Consider ObjectA and ObjectB are two different objects
 * that we want to find the shortest distance for. This method will
 * get the world direction vector of an object placed at the center of
 * objectA and is looking at the center of ObjectB. Then the dot product
 * of the world direction vector against every face normal on ObjectB.
 * If the dot product results in a negative number, than the face normal
 * is facing ObjectA and we will consider this a relevant face for calculating
 * shortest distance.
 *
 * Caveats: Very accurate but can include faces that face ObjectA but are not
 * necessarily the closest. For instance faces that are obstructed by other
 * closer faces to ObjectA.
 */
export function getRelevant(geomForCamera: any, geomToSimplify: any): {
    vertices: any[];
} | null;
/**
 * Get Faces From GL Read Pixels
 * Summary: This method boils down to using a another
 * webgl context to render an image of one object from the point of
 * view of the other object. The faces rendered are the ones relevant
 * to our calculations in finding the shortest distance.
 *
 * Detail: Let ObjectA and ObjectB be two different objects in 3D that we want
 * to find the shortest distance for. ObjectA and ObjectB need to be
 * constructed with modelItemToThreeGeometry so that each face on each object
 * is assigned a unique color. This method will position a camera at the center
 * of the bounding box of ObjectA and look at the center of the bounding box of
 * ObjectB. If ObjectB does not fit in the cameras frustum, then early out and
 * return null. Otherwise a new webgl context is used to project ObjectB using
 * the camera. When rendered, only the faces closest and facing ObjectA are
 * shown, and since each face is given a unique color, we can trace this color
 * back to the original face. Using `gl.readPixels` we can inspect each pixel
 * of the rendered image and collect an array of faces to be used in the
 * shortest distance calculation.
 *
 * Caveats: There are scenarios in which fitting the ObjectB in the camera's
 * frustum can be challenging. Distance and bounding boxes of the two objects
 * play a huge role in the accuracy of this method. This led to the early out
 * of requiring the ObjectB to fit fully in the frustum.
 *
 */
export function getFacesFromGLReadPixels(geomForCamera: any, geomToSimplify: any): {
    vertices: any[];
} | null;
export function shortestDistance(geometry1: any, geometry2: any): {
    method: string;
    start: import("three").Vector3;
    end: import("three").Vector3;
    distance: number;
};
export function computeShortestDistance(geometry1: any, geom1Relevant: null | undefined, geometry2: any, geom2Relevant?: null): {
    method: string;
    start: import("three").Vector3;
    end: import("three").Vector3;
    distance: number;
};
export function fUniqueEdgeRWhile(geomRelevant: any): any[][];
export function minFaceDistance(point: any, vertices: any, cp: any, triangle: any): {
    method: string;
    start: any;
    end: import("three").Vector3;
    distance: number;
};
export function closestLineToLine(s1: any, s2: any): {
    method: string;
    start: any;
    end: any;
    distance: any;
    segment_1: any;
    segment_2: any;
};
export function minEdgeEdgeDistance(line: any, edgesArr: any): undefined;
export function ConvertRadiansToDegrees(radians: any): number;
export function validate2DPoint(point: any): boolean;
export function isMac(): boolean;
export function escapeHtml(input: any): any;
/**
 * Calculates distance between two 3D positions
 *
 * @param {array} arrayA The first 3D position
 * @param {array} arrayB The second 3D position
 * @returns {number} The distance
 */
export function distanceBetween(arrayA: array, arrayB: array): number;
/**
 * Splices an array into chunks
 *
 * @param {array} arr The array to splice
 * @param {int} chunkSize The size of each array chunk
 * @returns {array} An array of arrays
 */
export function chunk(arr: array, chunkSize: int): array;
export function getCameraKey(bcfCamera: any): "perspective_camera" | "orthogonal_camera" | "perspective" | "orthogonal";
