acmi-parser 1.0.0 → 1.2.0

package/dist/types/acmi/acmiData.d.ts

@@ -0,0 +1,41 @@
+import { Dayjs } from 'dayjs';
+import { default as Entity } from './entity';
+import { default as Frame } from './frame';
+import { default as GlobalProperties } from './globalProperties';
+import { default as Header } from './header';
+import { default as TimeSpan } from './timeSpan';
+import { TrajectoryOptions, Trajectories } from '../trajectory/trajectory';
+/** Parsed ACMI recording, including metadata, entities, and scene snapshots. */
+export default class AcmiData {
+    /** Whether basic header, property, and timeline validation succeeded. */
+    isValid: boolean;
+    /** File type and ACMI version read from the header. */
+    header: Header;
+    /** Recording-level metadata and reference coordinates. */
+    globalProperties: GlobalProperties;
+    /** Absolute time range covered by the parsed frames. */
+    timeSpan: TimeSpan;
+    /** Entity metadata keyed by numeric ACMI entity ID. */
+    entities: Map<number, Entity>;
+    /** Chronologically ordered scene snapshots. */
+    frames: Array<Frame>;
+    private _searchFrameIndex;
+    /**
+     * Finds the latest frame at or before an absolute time.
+     *
+     * @param time - Absolute Day.js time to query.
+     * @returns The active frame, or `undefined` outside the recording time span.
+     */
+    getFrame(time: Dayjs): Frame | undefined;
+    private _addFrame;
+    /**
+     * Converts frame snapshots into trajectories sampled at a regular interval.
+     *
+     * @param options - Sampling interval and orientation-emulation settings.
+     * @returns Trajectories keyed by numeric ACMI entity ID.
+     * @throws `RangeError` if `sampleRate` is not finite and greater than zero.
+     * @remarks Unchanged intermediate states are omitted and the final state is
+     * always retained.
+     */
+    createSampledTrajectories(options?: TrajectoryOptions): Trajectories;
+}

package/dist/types/acmi/entity.d.ts

@@ -0,0 +1,26 @@
+import { default as TimeSpan } from './timeSpan';
+/** Metadata and active time range for one ACMI entity. */
+export default class Entity {
+    /** Numeric value of the entity's hexadecimal ACMI ID. */
+    id: number;
+    /** Absolute interval during which the entity exists. */
+    timeSpan: TimeSpan;
+    /** Human-readable entity name. */
+    name?: string;
+    /** Components of the ACMI `Type` property, split on `+`. */
+    types?: string[];
+    /** Radio call sign. */
+    callsign?: string;
+    /** Pilot name. */
+    pilot?: string;
+    /** Group or formation name. */
+    group?: string;
+    /** Country associated with the entity. */
+    country?: string;
+    /** Coalition associated with the entity. */
+    coalition?: string;
+    /** Source-provided display color. */
+    color?: string;
+    /** @param id - Numeric ACMI entity ID. */
+    constructor(id: number);
+}

package/dist/types/acmi/frame.d.ts

@@ -0,0 +1,17 @@
+import { default as ITransform } from './transform';
+/** Entity transforms keyed by numeric ACMI entity ID. */
+export type Scene = Map<number, ITransform>;
+/** Timestamped snapshot of all active, retained entities. */
+export default class Frame {
+    /** Seconds relative to the recording's reference time. */
+    timeStamp: number;
+    /** Entity transforms present at this timestamp. */
+    scene: Scene;
+    /**
+     * Creates a frame and shallow-copies an optional scene.
+     *
+     * @param timeStamp - Seconds relative to the recording's reference time.
+     * @param scene - Scene state to copy into the frame.
+     */
+    constructor(timeStamp: number, scene?: Scene);
+}

package/dist/types/acmi/globalProperties.d.ts

@@ -0,0 +1,30 @@
+import { default as dayjs, Dayjs } from 'dayjs';
+/** Recording-level properties declared on ACMI object `0`. */
+export default class GlobalProperties {
+    /** Absolute origin used to resolve frame and entity timestamps. */
+    referenceTime: dayjs.Dayjs;
+    /** Source application or system. */
+    dataSource?: string;
+    /** Name of the recording system. */
+    dataRecorder?: string;
+    /** Time at which the recording was created. */
+    recordingTime?: Dayjs;
+    /** Recording author. */
+    author?: string;
+    /** Recording title. */
+    title?: string;
+    /** Recording category. */
+    category?: string;
+    /** Briefing text. */
+    briefing?: string;
+    /** Debriefing text. */
+    debriefing?: string;
+    /** Free-form comments. */
+    comments?: string;
+    /** Longitude offset added to relative entity positions, in degrees. */
+    referenceLongitude?: number;
+    /** Latitude offset added to relative entity positions, in degrees. */
+    referenceLatitude?: number;
+    /** Unrecognized global properties preserved by name. */
+    additionalProps?: Map<string, string>;
+}

package/dist/types/acmi/header.d.ts

@@ -0,0 +1,7 @@
+/** ACMI file identification values read from the first two lines. */
+export default class Header {
+    /** MIME-like ACMI file type, normally `text/acmi/tacview`. */
+    fileType: string;
+    /** ACMI format version, such as `2.1` or `2.2`. */
+    fileVersion: string;
+}

package/dist/types/acmi/timeSpan.d.ts

@@ -0,0 +1,12 @@
+import { default as dayjs } from 'dayjs';
+/** Absolute start and end times for a recording or entity. */
+export default class TimeSpan {
+    /** Inclusive start time, or an invalid Day.js value when unknown. */
+    start: dayjs.Dayjs;
+    /** Inclusive end time, or an invalid Day.js value when unknown. */
+    end: dayjs.Dayjs;
+    /** @returns Whether both endpoints contain valid Day.js values. */
+    isValid(): boolean;
+    /** @returns Duration in seconds, or `-1` when the span is invalid. */
+    duration(): number;
+}

package/dist/types/acmi/transform.d.ts

@@ -0,0 +1,22 @@
+import { Vector3, Euler, Geoid } from '../math3d/index.ts';
+/** Geodetic position and optional orientation for an entity in one frame. */
+export default class Transform {
+    /** Longitude (degrees), latitude (degrees), and altitude (metres). */
+    position: Vector3;
+    /** Roll, pitch, and yaw in radians, when supplied by the recording. */
+    orientation?: Euler;
+    /** Global longitude offset in degrees used while decoding transforms. */
+    static refLong: number;
+    /** Global latitude offset in degrees used while decoding transforms. */
+    static refLat: number;
+    /** Optional geoid used to convert source altitudes. */
+    static geoid: Geoid | undefined;
+    /**
+     * Decodes ACMI transform components, inheriting omitted values.
+     *
+     * @param components - Longitude, latitude, altitude, roll, pitch, and yaw.
+     * Empty components are represented by `undefined`.
+     * @param previousTransform - Previous entity state used for omitted values.
+     */
+    constructor(components: (number | undefined)[], previousTransform: Transform | undefined);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+import { default as AcmiData } from './acmi/acmiData';
+import { default as Entity } from './acmi/entity';
+import { default as Frame, Scene } from './acmi/frame';
+import { default as GlobalProperties } from './acmi/globalProperties';
+import { default as Header } from './acmi/header';
+import { default as TimeSpan } from './acmi/timeSpan';
+import { default as Transform } from './acmi/transform';
+import { default as StateVector } from './trajectory/stateVector';
+import { default as Trajectory, ITrajectoryOptions, TrajectoryOptions, Trajectories } from './trajectory/trajectory';
+import { default as TrajectorySample, ITrajectorySample } from './trajectory/trajectorySample';
+import { default as AcmiParser, AcmiBinaryInput, AcmiInput, AcmiParseError, AcmiParseErrorCode, AcmiParserOptions, parseAcmi } from './parser';
+export type { Scene, ITrajectoryOptions, TrajectoryOptions, Trajectories, ITrajectorySample, TrajectorySample, AcmiBinaryInput, AcmiInput, AcmiParseErrorCode, AcmiParserOptions, };
+export { AcmiData, AcmiParseError, AcmiParser, Entity, Frame, GlobalProperties, Header, StateVector, TimeSpan, Trajectory, Transform, parseAcmi, };
+export default AcmiParser;

package/dist/types/math3d/core/classes/base/math-array.d.ts

@@ -0,0 +1,66 @@
+import { NumericArray } from '../../../types';
+import { ConfigurationOptions } from '../../lib/common';
+/** Base class for vectors and matrices */
+export declare abstract class MathArray extends Array<number> {
+    /** Number of elements (values) in this array */
+    abstract get ELEMENTS(): number;
+    abstract copy(vector: Readonly<NumericArray>): this;
+    abstract fromObject(object: Record<string, unknown>): this;
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
+    clone(): this;
+    fromArray(array: Readonly<NumericArray>, offset?: number): this;
+    toArray<TypedArray>(targetArray: TypedArray, offset?: number): TypedArray;
+    toArray(targetArray?: number[], offset?: number): NumericArray;
+    toObject(targetObject: Record<string, unknown>): Record<string, unknown>;
+    from(arrayOrObject: Readonly<NumericArray> | Record<string, unknown>): this;
+    to<T extends NumericArray | Record<string, unknown>>(arrayOrObject: T): T;
+    toTarget(target: this): this;
+    /** @deprecated */
+    toFloat32Array(): Float32Array;
+    toString(): string;
+    /** Formats string according to options */
+    formatString(opts: ConfigurationOptions): string;
+    equals(array: Readonly<NumericArray>): boolean;
+    exactEquals(array: Readonly<NumericArray>): boolean;
+    /** Negates all values in this object */
+    negate(): this;
+    /** Linearly interpolates between two values */
+    lerp(a: Readonly<NumericArray>, t: number): this;
+    lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray>, t: number): this;
+    /** Minimal */
+    min(vector: Readonly<NumericArray>): this;
+    /** Maximal */
+    max(vector: Readonly<NumericArray>): this;
+    clamp(minVector: Readonly<NumericArray>, maxVector: Readonly<NumericArray>): this;
+    add(...vectors: Readonly<NumericArray>[]): this;
+    subtract(...vectors: Readonly<NumericArray>[]): this;
+    scale(scale: number | Readonly<NumericArray>): this;
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
+    multiplyByScalar(scalar: number): this;
+    /** Throws an error if array length is incorrect or contains illegal values */
+    check(): this;
+    /** Returns false if the array length is incorrect or contains illegal values */
+    validate(): boolean;
+    /** @deprecated */
+    sub(a: Readonly<NumericArray>): this;
+    /** @deprecated */
+    setScalar(a: number): this;
+    /** @deprecated */
+    addScalar(a: number): this;
+    /** @deprecated */
+    subScalar(a: number): this;
+    /** @deprecated */
+    multiplyScalar(scalar: number): this;
+    /** @deprecated */
+    divideScalar(a: number): this;
+    /** @deprecated */
+    clampScalar(min: number, max: number): this;
+    /** @deprecated */
+    get elements(): NumericArray;
+}

package/dist/types/math3d/core/classes/base/matrix.d.ts

@@ -0,0 +1,13 @@
+import { NumericArray } from '../../../types';
+import { MathArray } from './math-array';
+/** Base class for matrices */
+export declare abstract class Matrix extends MathArray {
+    abstract get RANK(): number;
+    toString(): string;
+    getElementIndex(row: number, col: number): number;
+    getElement(row: number, col: number): number;
+    setElement(row: number, col: number, value: number): this;
+    getColumn<NumArrayT>(columnIndex: number, result: NumArrayT): NumArrayT;
+    getColumn(columnIndex: number): number[];
+    setColumn(columnIndex: number, columnVector: Readonly<NumericArray>): this;
+}

package/dist/types/math3d/core/classes/base/vector.d.ts

@@ -0,0 +1,43 @@
+import { NumericArray } from '../../../types';
+import { MathArray } from './math-array';
+/** Base class for vectors with at least 2 elements */
+export declare abstract class Vector extends MathArray {
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
+     */
+    len(): number;
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     */
+    magnitude(): number;
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
+    lengthSquared(): number;
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
+    magnitudeSquared(): number;
+    distance(mathArray: Readonly<NumericArray>): number;
+    distanceSquared(mathArray: Readonly<NumericArray>): number;
+    dot(mathArray: Readonly<NumericArray>): number;
+    normalize(): this;
+    multiply(...vectors: Readonly<NumericArray>[]): this;
+    divide(...vectors: Readonly<NumericArray>[]): this;
+    lengthSq(): number;
+    distanceTo(vector: Readonly<NumericArray>): number;
+    distanceToSquared(vector: Readonly<NumericArray>): number;
+    getComponent(i: number): number;
+    setComponent(i: number, value: number): this;
+    addVectors(a: Readonly<NumericArray>, b: Readonly<NumericArray>): this;
+    subVectors(a: Readonly<NumericArray>, b: Readonly<NumericArray>): this;
+    multiplyVectors(a: Readonly<NumericArray>, b: Readonly<NumericArray>): this;
+    addScaledVector(a: Readonly<NumericArray>, b: number): this;
+}

package/dist/types/math3d/core/classes/euler.d.ts

@@ -0,0 +1,78 @@
+import { MathArray } from './base/math-array';
+import { Quaternion } from './quaternion';
+import { NumericArray } from '../../types';
+declare enum RotationOrder {
+    ZYX = 0,
+    YXZ = 1,
+    XZY = 2,
+    ZXY = 3,
+    YZX = 4,
+    XYZ = 5
+}
+export declare class Euler extends MathArray {
+    static get ZYX(): RotationOrder;
+    static get YXZ(): RotationOrder;
+    static get XZY(): RotationOrder;
+    static get ZXY(): RotationOrder;
+    static get YZX(): RotationOrder;
+    static get XYZ(): RotationOrder;
+    static get RollPitchYaw(): RotationOrder;
+    static get DefaultOrder(): RotationOrder;
+    static get RotationOrders(): typeof RotationOrder;
+    static rotationOrder(order: RotationOrder): string;
+    get ELEMENTS(): number;
+    /**
+     * @class
+     * @param {Number | Number[]} x
+     * @param {Number=} [y]
+     * @param {Number=} [z]
+     * @param {Number=} [order]
+     */
+    constructor(x?: number, y?: number, z?: number, order?: RotationOrder);
+    fromQuaternion(quaternion: Readonly<NumericArray>): this;
+    fromObject(_object: Record<string, unknown>): this;
+    copy(array: Readonly<NumericArray>): this;
+    set(x: number | undefined, y: number | undefined, z: number | undefined, order: RotationOrder): this;
+    validate(): boolean;
+    toArray(array?: NumericArray, offset?: number): NumericArray;
+    toArray4(array?: NumericArray, offset?: number): NumericArray;
+    toVector3(result?: NumericArray): NumericArray;
+    toHeadingPitchRoll(): NumericArray;
+    toHeadingPitchRoll<T extends NumericArray>(result: T): T;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get alpha(): number;
+    set alpha(value: number);
+    get beta(): number;
+    set beta(value: number);
+    get gamma(): number;
+    set gamma(value: number);
+    get phi(): number;
+    set phi(value: number);
+    get theta(): number;
+    set theta(value: number);
+    get psi(): number;
+    set psi(value: number);
+    get roll(): number;
+    set roll(value: number);
+    get pitch(): number;
+    set pitch(value: number);
+    get yaw(): number;
+    set yaw(value: number);
+    get order(): RotationOrder;
+    set order(value: RotationOrder);
+    fromVector3(v: Readonly<NumericArray>, order: RotationOrder): this;
+    fromArray(array: Readonly<NumericArray>, offset?: number): this;
+    fromRollPitchYaw(roll: number, pitch: number, yaw: number): this;
+    fromRotationMatrix(m: Readonly<NumericArray>, order?: RotationOrder): this;
+    getRotationMatrix(m: NumericArray): NumericArray;
+    getQuaternion(): Quaternion;
+    _fromRotationMatrix(m: Readonly<NumericArray>, order?: RotationOrder): this;
+    _getRotationMatrix(result: NumericArray): NumericArray;
+    toQuaternion(): Quaternion;
+}
+export {};

package/dist/types/math3d/core/classes/matrix3.d.ts

@@ -0,0 +1,62 @@
+import { NumericArray } from '../../types';
+import { Matrix } from './base/matrix';
+declare enum INDICES {
+    COL0ROW0 = 0,
+    COL0ROW1 = 1,
+    COL0ROW2 = 2,
+    COL1ROW0 = 3,
+    COL1ROW1 = 4,
+    COL1ROW2 = 5,
+    COL2ROW0 = 6,
+    COL2ROW1 = 7,
+    COL2ROW2 = 8
+}
+export declare class Matrix3 extends Matrix {
+    static get IDENTITY(): Readonly<Matrix3>;
+    static get ZERO(): Readonly<Matrix3>;
+    get ELEMENTS(): number;
+    get RANK(): number;
+    get INDICES(): typeof INDICES;
+    constructor(array?: Readonly<NumericArray>);
+    /** @deprecated */
+    constructor(...args: number[]);
+    copy(array: Readonly<NumericArray>): this;
+    identity(): this;
+    /**
+     *
+     * @param object
+     * @returns self
+     */
+    fromObject(_object: {
+        [key: string]: any;
+    }): this;
+    /** Calculates a 3x3 matrix from the given quaternion
+     * q quat  Quaternion to create matrix from
+     */
+    fromQuaternion(q: Readonly<NumericArray>): this;
+    /**
+     * accepts column major order, stores in column major order
+     */
+    set(m00: number, m10: number, m20: number, m01: number, m11: number, m21: number, m02: number, m12: number, m22: number): this;
+    /**
+     * accepts row major order, stores as column major
+     */
+    setRowMajor(m00: number, m01: number, m02: number, m10: number, m11: number, m12: number, m20: number, m21: number, m22: number): this;
+    determinant(): number;
+    transpose(): this;
+    /** Invert a matrix. Note that this can fail if the matrix is not invertible */
+    invert(): this;
+    multiplyLeft(a: NumericArray): this;
+    multiplyRight(a: NumericArray): this;
+    rotate(radians: number): NumericArray;
+    scale(factor: NumericArray | number): this;
+    translate(vec: NumericArray): this;
+    transform(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /** @deprecated */
+    transformVector(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /** @deprecated */
+    transformVector2(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /** @deprecated */
+    transformVector3(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+}
+export {};

package/dist/types/math3d/core/classes/matrix4.d.ts

@@ -0,0 +1,232 @@
+import { NumericArray } from '../../types';
+import { Matrix } from './base/matrix';
+declare enum INDICES {
+    COL0ROW0 = 0,
+    COL0ROW1 = 1,
+    COL0ROW2 = 2,
+    COL0ROW3 = 3,
+    COL1ROW0 = 4,
+    COL1ROW1 = 5,
+    COL1ROW2 = 6,
+    COL1ROW3 = 7,
+    COL2ROW0 = 8,
+    COL2ROW1 = 9,
+    COL2ROW2 = 10,
+    COL2ROW3 = 11,
+    COL3ROW0 = 12,
+    COL3ROW1 = 13,
+    COL3ROW2 = 14,
+    COL3ROW3 = 15
+}
+/** 4x4 matrix */
+export declare class Matrix4 extends Matrix {
+    static get IDENTITY(): Readonly<Matrix4>;
+    static get ZERO(): Readonly<Matrix4>;
+    get ELEMENTS(): number;
+    get RANK(): number;
+    get INDICES(): typeof INDICES;
+    constructor(array?: Readonly<NumericArray>);
+    copy(array: Readonly<NumericArray>): this;
+    set(m00: number, m10: number, m20: number, m30: number, m01: number, m11: number, m21: number, m31: number, m02: number, m12: number, m22: number, m32: number, m03: number, m13: number, m23: number, m33: number): this;
+    setRowMajor(m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): this;
+    toRowMajor(result: NumericArray): NumericArray;
+    /** Set to identity matrix */
+    identity(): this;
+    /**
+     *
+     * @param object
+     * @returns self
+     */
+    fromObject(_object: {
+        [key: string]: any;
+    }): this;
+    /**
+     * Calculates a 4x4 matrix from the given quaternion
+     * @param quaternion Quaternion to create matrix from
+     * @returns self
+     */
+    fromQuaternion(quaternion: Readonly<NumericArray>): this;
+    /**
+     * Calculates a 4x4 matrix from the given translation and quaternion
+     * @param translation Vector3 to create matrix from
+     * @param quaternion Quaternion to create matrix from
+     * @returns self
+     */
+    fromTranslationQuaternion(translation: Readonly<NumericArray>, quaternion: Readonly<NumericArray>): this;
+    /**
+     * Generates a frustum matrix with the given bounds
+     * @param view.left - Left bound of the frustum
+     * @param view.right - Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top - Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far - Far bound of the frustum. Can be set to Infinity.
+     * @returns self
+     */
+    frustum(view: {
+        left: number;
+        right: number;
+        bottom: number;
+        top: number;
+        near: number;
+        far?: number;
+    }): this;
+    /**
+     * Generates a look-at matrix with the given eye position, focal point,
+     * and up axis
+     * @param view.eye - (vector) Position of the viewer
+     * @param view.center - (vector) Point the viewer is looking at
+     * @param view.up - (vector) Up axis
+     * @returns self
+     */
+    lookAt(view: {
+        eye: Readonly<NumericArray>;
+        center?: Readonly<NumericArray>;
+        up?: Readonly<NumericArray>;
+    }): this;
+    /**
+     * Generates a orthogonal projection matrix with the given bounds
+     * from "traditional" view space parameters
+     * @param view.left - Left bound of the frustum
+     * @param view.right number  Right bound of the frustum
+     * @param view.bottom - Bottom bound of the frustum
+     * @param view.top number  Top bound of the frustum
+     * @param view.near - Near bound of the frustum
+     * @param view.far number  Far bound of the frustum
+     * @returns self
+     */
+    ortho(view: {
+        left: number;
+        right: number;
+        bottom: number;
+        top: number;
+        near?: number;
+        far?: number;
+    }): this;
+    /**
+     * Generates an orthogonal projection matrix with the same parameters
+     * as a perspective matrix (plus focalDistance)
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. Typically viewport width / viewport height
+     * @param view.focalDistance Distance in the view frustum used for extent calculations
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
+    orthographic(view: {
+        fovy?: number;
+        aspect?: number;
+        focalDistance?: number;
+        near?: number;
+        far?: number;
+    }): this;
+    /**
+     * Generates a perspective projection matrix with the given bounds
+     * @param view.fovy Vertical field of view in radians
+     * @param view.aspect Aspect ratio. typically viewport width/height
+     * @param view.near Near bound of the frustum
+     * @param view.far Far bound of the frustum
+     * @returns self
+     */
+    perspective(view: {
+        fovy: number;
+        aspect?: number;
+        near?: number;
+        far?: number;
+    }): this;
+    determinant(): number;
+    /**
+     * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+     * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
+     * @param result
+     * @returns self
+     */
+    getScale<T extends NumericArray>(result: T): T;
+    /**
+     * Gets the translation portion, assuming the matrix is a affine transformation matrix.
+     * @param result
+     * @returns self
+     */
+    getTranslation<T extends NumericArray>(result: T): T;
+    /**
+     * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
+    getRotation<T extends NumericArray>(result: T, scaleResult?: NumericArray): T;
+    /**
+     *
+     * @param result
+     * @param scaleResult
+     * @returns self
+     */
+    getRotationMatrix3<T extends NumericArray>(result: T, scaleResult?: NumericArray): T;
+    transpose(): this;
+    invert(): this;
+    multiplyLeft(a: Readonly<NumericArray>): this;
+    multiplyRight(a: Readonly<NumericArray>): this;
+    rotateX(radians: number): this;
+    rotateY(radians: number): this;
+    /**
+     * Rotates a matrix by the given angle around the Z axis.
+     * @param radians
+     * @returns self
+     */
+    rotateZ(radians: number): this;
+    /**
+     *
+     * @param param0
+     * @returns self
+     */
+    rotateXYZ(angleXYZ: Readonly<NumericArray>): this;
+    /**
+     *
+     * @param radians
+     * @param axis
+     * @returns self
+     */
+    rotateAxis(radians: number, axis: Readonly<NumericArray>): this;
+    /**
+     *
+     * @param factor
+     * @returns self
+     */
+    scale(factor: number | Readonly<NumericArray>): this;
+    /**
+     *
+     * @param vec
+     * @returns self
+     */
+    translate(vector: Readonly<NumericArray>): this;
+    /**
+     * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
+     * @param vector
+     * @param result
+     * @returns self
+     */
+    transform(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /**
+     * Transforms any 2 or 3 element array as point (w implicitly 1)
+     * @param vector
+     * @param result
+     * @returns self
+     */
+    transformAsPoint(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /**
+     * Transforms any 2 or 3 element array as vector (w implicitly 0)
+     * @param vector
+     * @param result
+     * @returns self
+     */
+    transformAsVector(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /** @deprecated */
+    transformPoint(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /** @deprecated */
+    transformVector(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    /** @deprecated */
+    transformDirection(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    makeRotationX(radians: number): this;
+    makeTranslation(x: number, y: number, z: number): this;
+}
+export {};