acmi-parser 1.0.0 → 1.2.0

package/dist/types/math3d/core/gl-matrix/vec4.d.ts

@@ -0,0 +1,329 @@
+/**
+ * 4 Dimensional Vector
+ * @module vec4
+ */
+/**
+ * Creates a new, empty vec4
+ *
+ * @returns {vec4} a new 4D vector
+ */
+export declare function create(): any[] | Float32Array<ArrayBuffer>;
+/**
+ * Creates a new vec4 initialized with values from an existing vector
+ *
+ * @param {ReadonlyVec4} a vector to clone
+ * @returns {vec4} a new 4D vector
+ */
+export declare function clone(a: any): any[] | Float32Array<ArrayBuffer>;
+/**
+ * Creates a new vec4 initialized with the given values
+ *
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @param {Number} w W component
+ * @returns {vec4} a new 4D vector
+ */
+export declare function fromValues(x: any, y: any, z: any, w: any): any[] | Float32Array<ArrayBuffer>;
+/**
+ * Copy the values from one vec4 to another
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the source vector
+ * @returns {vec4} out
+ */
+export declare function copy(out: any, a: any): any;
+/**
+ * Set the components of a vec4 to the given values
+ *
+ * @param {vec4} out the receiving vector
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @param {Number} w W component
+ * @returns {vec4} out
+ */
+export declare function set(out: any, x: any, y: any, z: any, w: any): any;
+/**
+ * Adds two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {vec4} out
+ */
+export declare function add(out: any, a: any, b: any): any;
+/**
+ * Subtracts vector b from vector a
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {vec4} out
+ */
+export declare function subtract(out: any, a: any, b: any): any;
+/**
+ * Multiplies two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {vec4} out
+ */
+export declare function multiply(out: any, a: any, b: any): any;
+/**
+ * Divides two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {vec4} out
+ */
+export declare function divide(out: any, a: any, b: any): any;
+/**
+ * Math.ceil the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a vector to ceil
+ * @returns {vec4} out
+ */
+export declare function ceil(out: any, a: any): any;
+/**
+ * Math.floor the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a vector to floor
+ * @returns {vec4} out
+ */
+export declare function floor(out: any, a: any): any;
+/**
+ * Returns the minimum of two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {vec4} out
+ */
+export declare function min(out: any, a: any, b: any): any;
+/**
+ * Returns the maximum of two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {vec4} out
+ */
+export declare function max(out: any, a: any, b: any): any;
+/**
+ * symmetric round the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a vector to round
+ * @returns {vec4} out
+ */
+export declare function round(out: any, a: any): any;
+/**
+ * Scales a vec4 by a scalar number
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the vector to scale
+ * @param {Number} b amount to scale the vector by
+ * @returns {vec4} out
+ */
+export declare function scale(out: any, a: any, b: any): any;
+/**
+ * Adds two vec4's after scaling the second operand by a scalar value
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @param {Number} scale the amount to scale b by before adding
+ * @returns {vec4} out
+ */
+export declare function scaleAndAdd(out: any, a: any, b: any, scale: any): any;
+/**
+ * Calculates the euclidian distance between two vec4's
+ *
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {Number} distance between a and b
+ */
+export declare function distance(a: any, b: any): number;
+/**
+ * Calculates the squared euclidian distance between two vec4's
+ *
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {Number} squared distance between a and b
+ */
+export declare function squaredDistance(a: any, b: any): number;
+/**
+ * Calculates the length of a vec4
+ *
+ * @param {ReadonlyVec4} a vector to calculate length of
+ * @returns {Number} length of a
+ */
+export declare function length(a: any): number;
+/**
+ * Calculates the squared length of a vec4
+ *
+ * @param {ReadonlyVec4} a vector to calculate squared length of
+ * @returns {Number} squared length of a
+ */
+export declare function squaredLength(a: any): number;
+/**
+ * Negates the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a vector to negate
+ * @returns {vec4} out
+ */
+export declare function negate(out: any, a: any): any;
+/**
+ * Returns the inverse of the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a vector to invert
+ * @returns {vec4} out
+ */
+export declare function inverse(out: any, a: any): any;
+/**
+ * Normalize a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a vector to normalize
+ * @returns {vec4} out
+ */
+export declare function normalize(out: any, a: any): any;
+/**
+ * Calculates the dot product of two vec4's
+ *
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {Number} dot product of a and b
+ */
+export declare function dot(a: any, b: any): number;
+/**
+ * Returns the cross-product of three vectors in a 4-dimensional space
+ *
+ * @param {ReadonlyVec4} result the receiving vector
+ * @param {ReadonlyVec4} U the first vector
+ * @param {ReadonlyVec4} V the second vector
+ * @param {ReadonlyVec4} W the third vector
+ * @returns {vec4} result
+ */
+export declare function cross(out: any, u: any, v: any, w: any): any;
+/**
+ * Performs a linear interpolation between two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
+ * @returns {vec4} out
+ */
+export declare function lerp(out: any, a: any, b: any, t: any): any;
+/**
+ * Generates a random vector with the given scale
+ *
+ * @param {vec4} out the receiving vector
+ * @param {Number} [scale] Length of the resulting vector. If omitted, a unit vector will be returned
+ * @returns {vec4} out
+ */
+export declare function random(out: any, scale: any): any;
+/**
+ * Transforms the vec4 with a mat4.
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the vector to transform
+ * @param {ReadonlyMat4} m matrix to transform with
+ * @returns {vec4} out
+ */
+export declare function transformMat4(out: any, a: any, m: any): any;
+/**
+ * Transforms the vec4 with a quat
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the vector to transform
+ * @param {ReadonlyQuat} q quaternion to transform with
+ * @returns {vec4} out
+ */
+export declare function transformQuat(out: any, a: any, q: any): any;
+/**
+ * Set the components of a vec4 to zero
+ *
+ * @param {vec4} out the receiving vector
+ * @returns {vec4} out
+ */
+export declare function zero(out: any): any;
+/**
+ * Returns a string representation of a vector
+ *
+ * @param {ReadonlyVec4} a vector to represent as a string
+ * @returns {String} string representation of the vector
+ */
+export declare function str(a: any): string;
+/**
+ * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
+ *
+ * @param {ReadonlyVec4} a The first vector.
+ * @param {ReadonlyVec4} b The second vector.
+ * @returns {Boolean} True if the vectors are equal, false otherwise.
+ */
+export declare function exactEquals(a: any, b: any): boolean;
+/**
+ * Returns whether or not the vectors have approximately the same elements in the same position.
+ *
+ * @param {ReadonlyVec4} a The first vector.
+ * @param {ReadonlyVec4} b The second vector.
+ * @returns {Boolean} True if the vectors are equal, false otherwise.
+ */
+export declare function equals(a: any, b: any): boolean;
+/**
+ * Alias for {@link vec4.subtract}
+ * @function
+ */
+export declare const sub: typeof subtract;
+/**
+ * Alias for {@link vec4.multiply}
+ * @function
+ */
+export declare const mul: typeof multiply;
+/**
+ * Alias for {@link vec4.divide}
+ * @function
+ */
+export declare const div: typeof divide;
+/**
+ * Alias for {@link vec4.distance}
+ * @function
+ */
+export declare const dist: typeof distance;
+/**
+ * Alias for {@link vec4.squaredDistance}
+ * @function
+ */
+export declare const sqrDist: typeof squaredDistance;
+/**
+ * Alias for {@link vec4.length}
+ * @function
+ */
+export declare const len: typeof length;
+/**
+ * Alias for {@link vec4.squaredLength}
+ * @function
+ */
+export declare const sqrLen: typeof squaredLength;
+/**
+ * Perform some operation over an array of vec4s.
+ *
+ * @param {Array} a the array of vectors to iterate over
+ * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed
+ * @param {Number} offset Number of elements to skip at the beginning of the array
+ * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array
+ * @param {Function} fn Function to call for each vector in the array
+ * @param {Object} [arg] additional argument to pass to fn
+ * @returns {Array} a
+ * @function
+ */
+export declare const forEach: (a: any, stride: any, offset: any, count: any, fn: any, arg: any) => any;

package/dist/types/math3d/core/index.d.ts

@@ -0,0 +1,29 @@
+export type { TypedArray, NumericArray } from '../types';
+export type { isTypedArray, isNumericArray } from '../types';
+export { Vector2 } from './classes/vector2';
+export { Vector3 } from './classes/vector3';
+export { Vector4 } from './classes/vector4';
+export { Matrix3 } from './classes/matrix3';
+export { Matrix4 } from './classes/matrix4';
+export { Quaternion } from './classes/quaternion';
+export { SphericalCoordinates } from './classes/spherical-coordinates';
+export { Pose } from './classes/pose';
+export { Euler } from './classes/euler';
+export * as _MathUtils from './lib/math-utils';
+export { assert } from './lib/assert';
+export { config, configure, formatValue, isArray, clone, equals, exactEquals, toRadians, toDegrees, radians, degrees, sin, cos, tan, asin, acos, atan, clamp, lerp, withEpsilon, } from './lib/common';
+export { SphericalCoordinates as _SphericalCoordinates } from './classes/spherical-coordinates';
+export { Pose as _Pose } from './classes/pose';
+export { Euler as _Euler } from './classes/euler';
+/** @deprecated Use Matrix3 */
+export * as mat3 from './gl-matrix/mat3';
+/** @deprecated Use Matrix4 */
+export * as mat4 from './gl-matrix/mat4';
+/** @deprecated Use Quaterinion */
+export * as quat from './gl-matrix/quat';
+/** @deprecated UseVector */
+export * as vec2 from './gl-matrix/vec2';
+/** @deprecated Use Vector3 */
+export * as vec3 from './gl-matrix/vec3';
+/** @deprecated Use Vector4 */
+export * as vec4 from './gl-matrix/vec4';

package/dist/types/math3d/core/lib/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(condition: unknown, message?: string): void;

package/dist/types/math3d/core/lib/common.d.ts

@@ -0,0 +1,99 @@
+import { NumericArray } from '../../types';
+import { MathArray } from '../classes/base/math-array';
+export type ConfigurationOptions = {
+    EPSILON: number;
+    debug?: boolean;
+    precision: number;
+    printTypes?: boolean;
+    printDegrees?: boolean;
+    printRowMajor?: boolean;
+    _cartographicRadians?: boolean;
+};
+declare global {
+    var mathgl: {
+        config: Required<ConfigurationOptions>;
+    };
+}
+export declare const config: Required<ConfigurationOptions>;
+export declare function configure(options: Partial<ConfigurationOptions>): ConfigurationOptions;
+/**
+ * Formats a value into a string
+ * @param value
+ * @param param1
+ * @returns
+ */
+export declare function formatValue(value: number, { precision }?: {
+    precision?: number;
+}): string;
+/**
+ * Check if value is an "array"
+ * Returns `true` if value is either an array or a typed array
+ * Note: returns `false` for `ArrayBuffer` and `DataView` instances
+ * @note isTypedArray and isNumericArray are often more useful in TypeScript
+ */
+export declare function isArray(value: unknown): boolean;
+export declare function clone(array: NumericArray | MathArray): NumericArray;
+export declare function toRadians(degrees: number): number;
+export declare function toRadians(degrees: NumericArray): NumericArray;
+export declare function toDegrees(degrees: number): number;
+export declare function toDegrees(degrees: NumericArray): NumericArray;
+/**
+ * "GLSL equivalent" radians: Works on single values and vectors
+ */
+export declare function radians(degrees: number): number;
+export declare function radians(degrees: NumericArray, result?: NumericArray): NumericArray;
+/**
+ * "GLSL equivalent" degrees: Works on single values and vectors
+ */
+export declare function degrees(radians: number): number;
+export declare function degrees(radians: NumericArray, result?: NumericArray): NumericArray;
+/**
+ * "GLSL equivalent" of `Math.sin`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function sin(radians: number | NumericArray, result?: NumericArray): number | NumericArray;
+/**
+ * "GLSL equivalent" of `Math.cos`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function cos(radians: number | NumericArray, result?: NumericArray): number | NumericArray;
+/**
+ * "GLSL equivalent" of `Math.tan`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function tan(radians: number | NumericArray, result?: NumericArray): number | NumericArray;
+/**
+ * "GLSL equivalent" of `Math.asin`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function asin(radians: number | NumericArray, result?: NumericArray): number | NumericArray;
+/**
+ * "GLSL equivalent" of `Math.acos`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function acos(radians: number | NumericArray, result?: NumericArray): number | NumericArray;
+/**
+ * "GLSL equivalent" of `Math.atan`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function atan(radians: number | NumericArray, result?: NumericArray): number | NumericArray;
+/**
+ * GLSL style value clamping: Works on single values and vectors
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function clamp(value: NumericArray, min: number, max: number): NumericArray;
+/**
+ * Interpolate between two numbers or two arrays
+ */
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function lerp(a: NumericArray, b: NumericArray, t: number): NumericArray;
+/**
+ * Compares any two math objects, using `equals` method if available.
+ * @param a
+ * @param b
+ * @param epsilon
+ * @returns
+ */
+export declare function equals(a: any, b: any, epsilon?: number): boolean;
+export declare function exactEquals(a: any, b: any): boolean;
+export declare function withEpsilon<T>(epsilon: number, func: () => T): T;

package/dist/types/math3d/core/lib/gl-matrix-extras.d.ts

@@ -0,0 +1,6 @@
+import { NumericArray } from '../../types';
+export declare function vec2_transformMat4AsVector<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec3_transformMat4AsVector<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec3_transformMat2<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec4_transformMat2<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
+export declare function vec4_transformMat3<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;

package/dist/types/math3d/core/lib/math-utils.d.ts

@@ -0,0 +1,24 @@
+export declare const EPSILON1 = 0.1;
+export declare const EPSILON2 = 0.01;
+export declare const EPSILON3 = 0.001;
+export declare const EPSILON4 = 0.0001;
+export declare const EPSILON5 = 0.00001;
+export declare const EPSILON6 = 0.000001;
+export declare const EPSILON7 = 1e-7;
+export declare const EPSILON8 = 1e-8;
+export declare const EPSILON9 = 1e-9;
+export declare const EPSILON10 = 1e-10;
+export declare const EPSILON11 = 1e-11;
+export declare const EPSILON12 = 1e-12;
+export declare const EPSILON13 = 1e-13;
+export declare const EPSILON14 = 1e-14;
+export declare const EPSILON15 = 1e-15;
+export declare const EPSILON16 = 1e-16;
+export declare const EPSILON17 = 1e-17;
+export declare const EPSILON18 = 1e-18;
+export declare const EPSILON19 = 1e-19;
+export declare const EPSILON20 = 1e-20;
+export declare const PI_OVER_TWO: number;
+export declare const PI_OVER_FOUR: number;
+export declare const PI_OVER_SIX: number;
+export declare const TWO_PI: number;

package/dist/types/math3d/core/lib/validators.d.ts

@@ -0,0 +1,5 @@
+import { NumberArray } from '../../types';
+export declare function validateVector(v: NumberArray, length: number): boolean;
+export declare function checkNumber(value: unknown): number;
+export declare function checkVector<T extends NumberArray>(v: T, length: number, callerName?: string): T;
+export declare function deprecated(method: string, version: string): void;

package/dist/types/math3d/geoid/geoid.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Code is ported from GeographicLib-1.50.1
+ * https://geographiclib.sourceforge.io/html/index.html
+ * Location: /GeographicLib-1.50.1/src/Geoid.cpp
+ *           /GeographicLib-1.50.1/include/GeographicLib/Geoid.hpp
+ *           /GeographicLib-1.50.1/src/Math.cpp
+ *
+ * File header:
+ * * \file Geoid.cpp (Geoid.hpp)
+ * * \brief Implementation for GeographicLib::Geoid class
+ * *
+ * * Copyright (c) Charles Karney (2009-2018) <charles@karney.com> and licensed
+ * * under the MIT/X11 License.  For more information, see
+ * * https://geographiclib.sourceforge.io/
+ **********************************************************************/
+export type GeoidProps = {
+    cubic: boolean | undefined;
+    _width: number;
+    _height: number;
+    _rlonres: number;
+    _rlatres: number;
+    _offset: number;
+    _scale: number;
+    _swidth: number;
+    _datastart: number;
+    _maxerror: number;
+    _rmserror: number;
+    _description: string;
+    _datetime: string;
+    data: Uint8Array;
+};
+/**
+ * class Geoid - "Gravity Height Model"
+ * Calculates difference between mean see level height and WGS84 ellipsoid height
+ * Input data have to be loaded from "Earth Gravity Model" *.pgm file with "PGMLoader"
+ * A particular model file can be loaded on https://geographiclib.sourceforge.io/html/geoid.html
+ *
+ * The implementation is ported from GeographicLib-1.50.1
+ */
+export declare class Geoid {
+    private _v00;
+    private _v01;
+    private _v10;
+    private _v11;
+    private _t;
+    private _ix;
+    private _iy;
+    options: GeoidProps;
+    /**
+     * @constructs
+     * Create a Geoid instance.
+     * @param options - object which includes parameters parsed from *.pgm header
+     * @param options.data - binary buffer of *.pgm file
+     */
+    constructor(options: GeoidProps);
+    /**
+     * Calculates difference between mean see level height and WGS84 ellipsoid height
+     * Code is ported from /GeographicLib-1.50.1/src/Geoid.cpp
+     * @param lat - latitude
+     * @param lon - longitude
+     * @returns height in meters
+     */
+    getHeight(lat: number, lon: number): number;
+    /**
+     * Method seeks for particular data in th pgm buffer
+     * Code is ported from corresponding method
+     * in /GeographicLib-1.50.1/include/GeographicLib/Geoid.hpp
+     * @param {number} ix - longituge parameter
+     * @param {number} iy - latitude parameter
+     * @returns {number} data from pgm binary buffer
+     */
+    private _rawval;
+}

package/dist/types/math3d/geoid/index.d.ts

@@ -0,0 +1,2 @@
+export { parsePGM } from './parse-pgm';
+export { Geoid } from './geoid';

package/dist/types/math3d/geoid/parse-pgm.d.ts

@@ -0,0 +1,11 @@
+import { Geoid } from './geoid';
+/**
+ * Parse "Earth Gravity Model" loaded from a *.pgm file
+ * https://geographiclib.sourceforge.io/html/geoid.html
+ * @param {} data - binary buffer of pgm file
+ * @param {Object} options - loader options
+ * @returns {GeoidHeightModel} - instance of GeoidHeightModel class
+ */
+export declare function parsePGM(data: Uint8Array, options: {
+    cubic?: boolean;
+}): Geoid;

package/dist/types/math3d/geospatial/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const WGS84_RADIUS_X = 6378137;
+export declare const WGS84_RADIUS_Y = 6378137;
+export declare const WGS84_RADIUS_Z = 6356752.314245179;
+export declare const WGS84_CONSTANTS: {
+    radii: number[];
+    radiiSquared: number[];
+    oneOverRadii: number[];
+    oneOverRadiiSquared: number[];
+    maximumRadius: number;
+    centerToleranceSquared: number;
+};

package/dist/types/math3d/geospatial/ellipsoid/ellipsoid.d.ts

@@ -0,0 +1,69 @@
+import { Euler, Vector3, Matrix3, Quaternion, NumericArray } from '../../core';
+import { AxisDirection } from './helpers/ellipsoid-transform';
+/**
+ * A quadratic surface defined in Cartesian coordinates by the equation
+ * `(x / a)^2 + (y / b)^2 + (z / c)^2 = 1`.  Primarily used
+ * to represent the shape of planetary bodies.
+ */
+export declare class Ellipsoid {
+    /** An Ellipsoid instance initialized to the WGS84 standard. */
+    static readonly WGS84: Ellipsoid;
+    readonly radii: Vector3;
+    readonly radiiSquared: Vector3;
+    readonly radiiToTheFourth: Vector3;
+    readonly oneOverRadii: Vector3;
+    readonly oneOverRadiiSquared: Vector3;
+    readonly minimumRadius: number;
+    readonly maximumRadius: number;
+    readonly centerToleranceSquared: number;
+    readonly squaredXOverSquaredZ: number;
+    /** Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions. */
+    constructor(x: number, y: number, z: number);
+    constructor();
+    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
+    equals(right: Ellipsoid): boolean;
+    /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
+    toString(): string;
+    /** Converts the provided cartographic to Cartesian representation. */
+    cartographicToCartesian(cartographic: number[], result: Vector3): Vector3;
+    cartographicToCartesian(cartographic: number[], result?: number[]): number[];
+    /** Converts the provided cartesian to cartographic (lng/lat/z) representation.
+     * The cartesian is undefined at the center of the ellipsoid. */
+    cartesianToCartographic(cartesian: Readonly<NumericArray>, result: Vector3): Vector3;
+    cartesianToCartographic(cartesian: Readonly<NumericArray>, result?: number[]): number[];
+    /** Computes a 4x4 transformation matrix from a reference frame with an east-north-up axes
+     * centered at the provided origin to the provided ellipsoid's fixed reference frame. */
+    eastNorthUpToFixedFrame<T extends NumericArray>(origin: Readonly<NumericArray>, result?: T): T;
+    /** Computes a 4x4 transformation matrix from a reference frame centered at
+     * the provided origin to the ellipsoid's fixed reference frame.
+     */
+    localFrameToFixedFrame<T extends NumericArray>(firstAxis: AxisDirection, secondAxis: AxisDirection, thirdAxis: AxisDirection, origin: Readonly<NumericArray>, result?: T): T;
+    /** Computes the unit vector directed from the center of this ellipsoid toward
+     * the provided Cartesian position. */
+    geocentricSurfaceNormal(cartesian: number[], result?: number[]): number[];
+    geocentricSurfaceNormal<NumArray>(cartesian: number[], result: NumArray): NumArray;
+    /** Computes the normal of the plane tangent to the surface of the ellipsoid at provided position. */
+    geodeticSurfaceNormalCartographic<NumArray>(cartographic: Readonly<NumericArray>, result: NumArray): NumArray;
+    geodeticSurfaceNormalCartographic(cartographic: number[]): number[];
+    /** Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position. */
+    geodeticSurfaceNormal<NumArrayT>(cartesian: number[], result: NumArrayT): NumArrayT;
+    geodeticSurfaceNormal(cartesian: number[]): number[];
+    /** Scales the provided Cartesian position along the geodetic surface normal
+     * so that it is on the surface of this ellipsoid.  If the position is
+     * at the center of the ellipsoid, this function returns undefined. */
+    scaleToGeodeticSurface(cartesian: number[], result?: number[]): number[] | undefined;
+    /** Scales the provided Cartesian position along the geocentric surface normal
+     * so that it is on the surface of this ellipsoid. */
+    scaleToGeocentricSurface(cartesian: number[], result?: number[]): number[];
+    /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#oneOverRadii` */
+    transformPositionToScaledSpace(position: number[], result?: number[]): number[];
+    /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#radii`. */
+    transformPositionFromScaledSpace(position: number[], result?: number[]): number[];
+    /** Computes a point which is the intersection of the surface normal with the z-axis. */
+    getSurfaceNormalIntersectionWithZAxis(position: number[], buffer?: number, result?: number[]): number[] | undefined;
+    getEulerFromPositionQuaternion(position: Readonly<NumericArray>, quaternion: Readonly<NumericArray>, result?: Euler): Euler;
+    getRotationMatrixFromPositionVelocity(position: Readonly<NumericArray>, velocity: Readonly<NumericArray>, result?: Matrix3): Matrix3;
+    getQuaternionFromEuler(position: Readonly<NumericArray>, e: Euler, result?: Quaternion): Quaternion;
+}

package/dist/types/math3d/geospatial/ellipsoid/helpers/ellipsoid-transform.d.ts

@@ -0,0 +1,4 @@
+import { NumericArray } from '../../../core';
+import { Ellipsoid } from '../ellipsoid';
+export type AxisDirection = "up" | "down" | "north" | "east" | "south" | "west";
+export declare function localFrameToFixedFrame<T extends NumericArray>(ellipsoid: Ellipsoid, firstAxis: AxisDirection, secondAxis: AxisDirection, thirdAxis: AxisDirection, cartesianOrigin: Readonly<NumericArray>, result: T): T;

package/dist/types/math3d/geospatial/ellipsoid/helpers/scale-to-geodetic-surface.d.ts

@@ -0,0 +1,2 @@
+import { Ellipsoid } from '../ellipsoid';
+export declare function scaleToGeodeticSurface(cartesian: number[], ellipsoid: Ellipsoid, result?: number[]): number[] | undefined;