declare namespace IG.Math {
    const Deg2Rad: number;
    const Rad2Deg: number;
    function clamp(input: number, min: number, max: number): number;
    function isCloseTo(first: number, second: number, deviation?: number): boolean;
    function arithmeticMean(array: number[]): number | null;
    function median(array: number[]): number | null;
    function degToRad(angle: number): number;
    function radToDeg(angle: number): number;
    function cartToPolarRad(direction: IG.Math.Vector3): {
        azimuth: number;
        elevation: number;
        radius: number;
    };
    function cartToPolarDeg(direction: IG.Math.Vector3): {
        azimuth: number;
        elevation: number;
        radius: number;
    };
    function polarToCartRad(azimuthRad: number, elevationRad: number, radius?: number): IG.Math.Vector3;
    function polarToCartDeg(azimuthDeg: number, elevationDeg: number, radius: number): IG.Math.Vector3;
    function copysign(x: number, y: number): number;
    class Vector2 {
        x: number;
        y: number;
        constructor(x: number, y: number);
        static create(x?: number, y?: number): Vector2;
        static clone(input: Vector2): Vector2;
        static copy(from: Vector2, to: Vector2): void;
        static isEqual(first: Vector2, second: Vector2, deviation?: number): boolean;
        static absoluteComponents(input: Vector2): Vector2;
        static normalize(vector: Vector2, length?: number): Vector2 | undefined;
        static normalizeInPlace(vector: Vector2, length?: number): void;
        static add(...vectors: Vector2[]): Vector2;
        static addOnFirst(...vectors: Vector2[]): Vector2 | undefined;
        static sub(first: Vector2, second: Vector2): Vector2;
        static subOnFirst(...vectors: Vector2[]): Vector2 | undefined;
        static innerProduct(first: Vector2, second: Vector2): number;
        static scalarAdd(offset: number, vector: Vector2): Vector2;
        static scalarAddInPlace(offset: number, vector: Vector2): void;
        static scalarMultiply(scalar: number, vector: Vector2): Vector2;
        static scalarMultiplyInPlace(scalar: number, vector: Vector2): void;
        static magnitude(vector: Vector2): number;
        static magnitudeSquared(vector: Vector2): number;
        static distance(first: Vector2, second: Vector2): number;
        static maximizeInPlace(input: Vector2, ...vectors: Vector2[]): void;
        static minimizeInPlace(input: Vector2, ...vectors: Vector2[]): void;
        static reverse(vector: Vector2): Vector2;
        static reverseInPlace(vector: Vector2): Vector2;
        static angleBetween(v: Vector2, w: Vector2): number;
        static stringify(v: Vector2, precision?: number): string;
        static hasInvalidEntries(v: Vector2): boolean;
    }
    class Vector3 {
        x: number;
        y: number;
        z: number;
        constructor(x: number, y: number, z: number);
        static create(x?: number, y?: number, z?: number): Vector3;
        static clone(input: Vector3): Vector3;
        static copy(from: Vector3, to: Vector3): void;
        static isEqual(first: Vector3, second: Vector3, deviation?: number): boolean;
        static absoluteComponents(input: Vector3): Vector3;
        static normalize(vector: Vector3, length?: number): Vector3 | undefined;
        static normalizeInPlace(vector: Vector3, length?: number): void;
        static add(...vectors: Vector3[]): Vector3;
        static addOnFirst(...vectors: Vector3[]): Vector3 | undefined;
        static sub(first: Vector3, second: Vector3): Vector3;
        static subOnFirst(...vectors: Vector3[]): Vector3 | undefined;
        static innerProduct(first: Vector3, second: Vector3): number;
        static crossProduct(first: Vector3, second: Vector3): Vector3;
        static multiplyWithMatrix4(vector: Vector3, matrix: IG.Math.Matrix4): Vector3;
        static scalarAdd(offset: number, vector: Vector3): Vector3;
        static scalarAddInPlace(offset: number, vector: Vector3): void;
        static scalarMultiply(scalar: number, vector: Vector3): Vector3;
        static scalarMultiplyInPlace(scalar: number, vector: Vector3): void;
        static magnitude(vector: Vector3): number;
        static magnitudeSquared(vector: Vector3): number;
        static distance(first: Vector3, second: Vector3): number;
        static maximizeInPlace(input: Vector3, ...vectors: Vector3[]): void;
        static minimizeInPlace(input: Vector3, ...vectors: Vector3[]): void;
        static reverse(vector: Vector3): Vector3;
        static reverseInPlace(vector: Vector3): Vector3;
        static angleBetween(v: Vector3, w: Vector3): number;
        static rotate(v: Vector3, eulerRotation: IG.Math.Euler): Vector3;
        static stringify(v: Vector3, precision?: number): string;
        static hasInvalidEntries(v: Vector3): boolean;
    }
    class Vector4 {
        x: number;
        y: number;
        z: number;
        w: number;
        constructor(x: number, y: number, z: number, w: number);
        static create(x?: number, y?: number, z?: number, w?: number): Vector4;
        static clone(input: Vector4): Vector4;
        static copy(from: Vector4, to: Vector4): void;
        static isEqual(first: Vector4, second: Vector4, deviation?: number): boolean;
        static absoluteComponents(input: Vector4): Vector4;
        static normalize(vector: Vector4, length?: number): Vector4 | undefined;
        static normalizeInPlace(vector: Vector4, length?: number): void;
        static add(...vectors: Vector4[]): Vector4;
        static addOnFirst(...vectors: Vector4[]): Vector4 | undefined;
        static sub(first: Vector4, second: Vector4): Vector4;
        static subOnFirst(...vectors: Vector4[]): Vector4 | undefined;
        static innerProduct(first: Vector4, second: Vector4): number;
        static multiplyWithMatrix4(f: Vector4, matrix: IG.Math.Matrix4): Vector4;
        static scalarAdd(offset: number, vector: Vector4): Vector4;
        static scalarAddInPlace(offset: number, vector: Vector4): void;
        static scalarMultiply(scalar: number, vector: Vector4): Vector4;
        static scalarMultiplyInPlace(scalar: number, vector: Vector4): void;
        static magnitude(vector: Vector4): number;
        static magnitudeSquared(vector: Vector4): number;
        static distance(first: Vector4, second: Vector4): number;
        static maximizeInPlace(input: Vector4, ...vectors: Vector4[]): void;
        static minimizeInPlace(input: Vector4, ...vectors: Vector4[]): void;
        static reverse(vector: Vector4): Vector4;
        static reverseInPlace(vector: Vector4): Vector4;
        static stringify(v: Vector4, precision?: number): string;
        static hasInvalidEntries(v: Vector4): boolean;
    }
    class Quaternion extends Vector4 {
        constructor(_x: number, _y: number, _z: number, _w: number);
        static create(x?: number, y?: number, z?: number, w?: number): Quaternion;
        static createFromEuler(euler: IG.Math.Euler): Quaternion;
        static createFromRotationMatrix(m: IG.Math.Matrix4): Quaternion;
        static createFromUnitVectors(u: IG.Math.Vector3, v: IG.Math.Vector3): Quaternion;
        static createFromVectors(u: IG.Math.Vector3, v: IG.Math.Vector3): Quaternion;
        static CreateFromAxisAngle(axis: IG.Math.Vector3, angle: number): Quaternion;
        static angleBetween(q1: Quaternion, q2: Quaternion): number;
        static add(q1: Quaternion, q2: Quaternion): Quaternion;
        static multiply(q1: Quaternion, q2: Quaternion): Quaternion;
        static stringify(q: Quaternion): string;
    }
    class Matrix3 {
        elements: [[number, number, number], [number, number, number], [number, number, number]];
        constructor(elements: [[number, number, number], [number, number, number], [number, number, number]]);
        static create(elements?: number[][]): Matrix3;
        static identity(): Matrix3;
        static set(matrix: Matrix3, n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number): void;
        static clone(matrix: Matrix3): Matrix3;
        static copy(from: Matrix3, to: Matrix3): void;
        static absoluteElements(input: Matrix3): Matrix3;
        static add(matA: Matrix3, matB: Matrix3): Matrix3;
        static multiplyScalar(matrix: Matrix3, scalar: number): Matrix3;
        static multiply(matA: Matrix3, matB: Matrix3): Matrix3;
        static multiplyWithVector3(vector: IG.Math.Vector3, matrix: Matrix3): IG.Math.Vector3;
        static getInverse(matrix: Matrix3): Matrix3 | undefined;
        static transpose(matrix: Matrix3): Matrix3;
        static getScale(scale: IG.Math.Vector3): Matrix3;
        static makeRotationMatrixFromNormalVector(rotationNormal: IG.Math.Vector3, angRad: number): Matrix3;
        static getXRotationMatrix(angle: number): Matrix3;
        static getYRotationMatrix(angle: number): Matrix3;
        static getZRotationMatrix(angle: number): Matrix3;
        static determinant(matrix: Matrix3): number;
        static equals(matA: Matrix3, matB: Matrix3): boolean;
        static stringify(matrix: Matrix3): String;
    }
    class Matrix4 {
        elements: [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]];
        constructor(elements: [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]]);
        static create(elements?: number[][]): Matrix4;
        static createFromQuaternion(quaternion: IG.Math.Quaternion): Matrix4;
        static identity(): Matrix4;
        static set(matrix: Matrix4, n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number): void;
        static clone(matrix: Matrix4): Matrix4;
        static copy(from: Matrix4, to: Matrix4): void;
        static absoluteElements(input: Matrix4): Matrix4;
        static add(matA: Matrix4, matB: Matrix4): Matrix4;
        static multiplyScalar(matrix: Matrix4, scalar: number): Matrix4;
        static multiply(a: Matrix4, b: Matrix4): Matrix4;
        static getInverse(matrix: Matrix4): Matrix4 | undefined;
        static transpose(matrix: Matrix4): Matrix4;
        static getScaleMatrix(scale: IG.Math.Vector3): Matrix4;
        static makeRotationMatrixFromQuaternionInPlace(matrix: Matrix4, quaternion: IG.Math.Quaternion): void;
        static getXRotationMatrix(angle: number): Matrix4;
        static getYRotationMatrix(angle: number): Matrix4;
        static getZRotationMatrix(angle: number): Matrix4;
        static getTranslationMatrix(pos: IG.Math.Vector3): Matrix4;
        static compose(translation: IG.Math.Vector3, rotation: IG.Math.Quaternion, scale: IG.Math.Vector3): Matrix4;
        static decompose(matrix: Matrix4): Object[];
        static lookAt(eye: IG.Math.Vector3, target: IG.Math.Vector3, up?: IG.Math.Vector3, base?: string): Matrix4;
        static determinant(matrix: Matrix4): number;
        static equals(matA: Matrix4, matB: Matrix4): boolean;
        static stringify(matrix: Matrix4): String;
    }
    class Ray {
        origin: IG.Math.Vector3;
        direction: IG.Math.Vector3;
        constructor(origin: Vector3, direction: Vector3);
        static create(origin: IG.Math.Vector3, direction: IG.Math.Vector3): Ray;
        static clone(ray: Ray): Ray;
    }
    class LineSegment {
        point: IG.Math.Vector3;
        border: IG.Math.Vector3;
        constructor(point: Vector3, border: Vector3);
        static convertToLine(segment: LineSegment): Line;
    }
    class Line {
        point: IG.Math.Vector3;
        direction: IG.Math.Vector3;
        constructor(_point: Vector3, _direction: Vector3);
        static create(point: IG.Math.Vector3, direction: IG.Math.Vector3): Line;
        static clone(ray: Line): Line;
    }
    class PlaneSegment {
        point: IG.Math.Vector3;
        borderU: IG.Math.Vector3;
        borderV: IG.Math.Vector3;
        constructor(point: Vector3, borderU: Vector3, borderV: Vector3);
        static convertToPlane(segment: PlaneSegment): Plane;
    }
    class Plane {
        normal: IG.Math.Vector3;
        point: IG.Math.Vector3;
        constructor(_normal: Vector3, _point: Vector3);
        static create(point: IG.Math.Vector3, normal: IG.Math.Vector3): Plane;
        static clone(plane: Plane): Plane;
    }
    class Transformation {
        position: IG.Math.Vector3;
        rotation: IG.Math.Vector3;
        constructor(position: Vector3, rotation: Vector3);
        static create(position: IG.Math.Vector3, rotation: IG.Math.Vector3): Transformation;
        static clone(transformation: Transformation): Transformation;
    }
    class Bounds {
        min: IG.Math.Vector3;
        max: IG.Math.Vector3;
        constructor(min: Vector3, max: Vector3);
        static create(min?: IG.Math.Vector3, max?: IG.Math.Vector3): Bounds;
        static clone(bounds: Bounds): Bounds;
        static areValid(bounds: Bounds): boolean;
        static doIntersect(bb1: Bounds, bb2: Bounds): boolean;
        static isPointInBounds(bounds: Bounds, point: IG.Math.Vector3, deviation?: number): boolean;
        static ensureBoundsAreAssorted(bounds: Bounds): void;
        static extendInPlace(bounds: Bounds, point: IG.Math.Vector3): void;
        static merge(first: Bounds, second: Bounds): Bounds;
        static convertToXZPlaneSegment(bounds: Bounds): IG.Math.PlaneSegment;
        static stringify(bounds: Bounds, precision?: number): string;
        static getSize(bounds: Bounds): IG.Math.Vector3;
        static getCenter(bounds: Bounds): IG.Math.Vector3;
    }
    type EulerOrders = "xyz";
    class Euler {
        x: number;
        y: number;
        z: number;
        order: EulerOrders;
        constructor(x: number, y: number, z: number, order: EulerOrders);
        static create(x?: number, y?: number, z?: number, order?: EulerOrders): Euler;
        private static threeaxisrot;
        static createFromQuaternion(quaternion: IG.Math.Quaternion, order?: EulerOrders): Euler;
        static createFromRotationMatrix(matrix: IG.Math.Matrix4, order?: EulerOrders): Euler;
    }
    namespace LinearAlgebra {
        function getIntersectionPoint(ray: IG.Math.Ray, plane: IG.Math.Plane): IG.Math.Vector3 | null;
        function factorOfDirectionFromRayToPlane(ray: IG.Math.Ray, plane: IG.Math.Plane): number | null;
        function projectToPlane(point: IG.Math.Vector3, plane: IG.Math.Plane): IG.Math.Vector3 | null;
        function isInUpperHalfSpace(point: IG.Math.Vector3, plane: IG.Math.Plane): boolean;
        function isInLowerHalfSpace(point: IG.Math.Vector3, plane: IG.Math.Plane): boolean;
        function distanceToPlane(point: IG.Math.Vector3, plane: IG.Math.Plane): number;
        function closestPointOnLine(line: IG.Math.Line, point: IG.Math.Vector3): IG.Math.Vector3 | null;
        function distanceToPlaneSegment(segment: IG.Math.PlaneSegment, point: IG.Math.Vector3): number;
        function projectToPlaneSegment(segment: IG.Math.PlaneSegment, point: IG.Math.Vector3): IG.Math.Vector3;
        function distanceToLineSegment(segment: IG.Math.LineSegment, point: IG.Math.Vector3): number;
        function isPointOnLineSegment(segment: IG.Math.LineSegment, point: IG.Math.Vector3): boolean;
        function projectToLineSegment(segment: IG.Math.LineSegment, point: IG.Math.Vector3): IG.Math.Vector3;
        function isInsidePlaneSegment(segment: IG.Math.PlaneSegment, point: IG.Math.Vector3): boolean;
        function lineSegmentsOfPlaneSegment(segment: IG.Math.PlaneSegment): IG.Math.LineSegment[];
        function rotateVectorAAroundPointBByNormalCWithRadiantAngle(vectorA: IG.Math.Vector3, vectorB: IG.Math.Vector3, normalVector: IG.Math.Vector3, angle: number): IG.Math.Vector3;
        function getOrderedIntersectionFactor(ray: IG.Math.Ray, plane: IG.Math.Plane): number | null;
        function intersectPlanes(p1: IG.Math.Plane, p2: IG.Math.Plane): IG.Math.Ray | null;
        function intersectionPoint(ray: IG.Math.Ray, plane: IG.Math.Plane): IG.Math.Vector3 | null;
    }
    namespace MathS {
        function tan(x: number): number;
        function asin(x: number): number;
        function acos(x: number): number;
        function sqrt(x: number): number;
    }
}