ootk 7.0.0 → 7.0.1

package/dist/main.d.ts

@@ -1181,83 +1181,6 @@ declare class EquinoctialElements {
     toPositionVelocity(): PositionVelocity;
 }
 
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * A state vector is a set of coordinates used to specify the position and
- * velocity of an object in a particular reference frame.
- */
-declare abstract class StateVector {
-    epoch: EpochUTC;
-    position: Vector3D<Kilometers>;
-    velocity: Vector3D<KilometersPerSecond>;
-    constructor(epoch: EpochUTC, position: Vector3D<Kilometers>, velocity: Vector3D<KilometersPerSecond>);
-    /**
-     * The name of the reference frame in which the state vector is defined.
-     * @returns The name of the reference frame.
-     */
-    abstract get name(): string;
-    /**
-     * Whether the state vector is defined in an inertial reference frame.
-     * @returns True if the state vector is defined in an inertial reference
-     */
-    abstract get inertial(): boolean;
-    /**
-     * Returns a string representation of the StateVector object. The string includes the name, epoch, position, and
-     * velocity.
-     * @returns A string representation of the StateVector object.
-     */
-    toString(): string;
-    /**
-     * Calculates the mechanical energy of the state vector.
-     * @returns The mechanical energy value.
-     */
-    get mechanicalEnergy(): number;
-    /**
-     * Calculates the semimajor axis of the state vector.
-     * @returns The semimajor axis in kilometers.
-     */
-    get semimajorAxis(): Kilometers;
-    /**
-     * Gets the period of the state vector in minutes.
-     * @returns The period in minutes.
-     */
-    get period(): Minutes;
-    /**
-     * Gets the angular rate of the state vector.
-     * @returns The angular rate.
-     */
-    get angularRate(): number;
-    /**
-     * Converts the state vector to classical elements.
-     * @param mu The gravitational parameter of the celestial body. Defaults to Earth's gravitational parameter.
-     * @returns The classical elements corresponding to the state vector.
-     * @throws Error if classical elements are undefined for fixed frames.
-     */
-    toClassicalElements(mu?: number): ClassicalElements;
-}
-
 /**
  * @author Theodore Kruczek
  * @description Orbital Object ToolKit (ootk) is a collection of tools for working
@@ -1448,281 +1371,243 @@ declare class ClassicalElements {
  */
 
 /**
- * True Equator Mean Equinox (TEME) is a coordinate system commonly used in satellite tracking and orbit prediction. It
- * is a reference frame that defines the position and orientation of an object relative to the Earth's equator and
- * equinox.
- *
- * By using the True Equator Mean Equinox (TEME) coordinate system, we can accurately describe the position and motion
- * of satellites relative to the Earth's equator and equinox. This is particularly useful for tracking and predicting
- * satellite orbits in various applications, such as satellite communication, navigation, and remote sensing.
+ * A Vector is a mathematical object that has both magnitude and direction.
  */
-declare class TEME extends StateVector {
+declare class Vector<T extends number = number> {
+    elements: T[] | Float64Array;
     /**
-     * Gets the name of the coordinate system.
-     * @returns The name of the coordinate system.
+     * The length of the vector.
      */
-    get name(): string;
+    readonly length: number;
     /**
-     * Gets a value indicating whether the coordinate is inertial.
-     * @returns A boolean value indicating whether the coordinate is inertial.
+     * Represents a 3-dimensional vector.
      */
-    get inertial(): boolean;
+    static readonly origin3: Vector<0>;
     /**
-     * Creates a TEME (True Equator Mean Equinox) object from classical orbital elements.
-     * @param elements - The classical orbital elements.
-     * @returns A new TEME object.
+     * Represents a vector with all elements set to zero.
      */
-    static fromClassicalElements(elements: ClassicalElements): TEME;
+    static readonly origin6: Vector<0>;
     /**
-     * Converts the TEME (True Equator Mean Equinox) coordinates to J2000 coordinates.
-     * @returns The J2000 coordinates.
+     * Represents the x-axis vector.
      */
-    toJ2000(): J2000;
-}
-
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * Represents a position and velocity in the J2000 coordinate system. This is an Earth-centered inertial (ECI)
- * coordinate system.
- *
- * Commonly used ECI frame is defined with the Earth's Mean Equator and Mean Equinox (MEME) at 12:00 Terrestrial Time on
- * 1 January 2000. It can be referred to as J2K, J2000 or EME2000. The x-axis is aligned with the mean vernal equinox.
- * The z-axis is aligned with the Earth's rotation axis (or equivalently, the celestial North Pole) as it was at that
- * time. The y-axis is rotated by 90° East about the celestial equator.
- * @see https://en.wikipedia.org/wiki/Earth-centered_inertial
- */
-declare class J2000 extends StateVector {
+    static readonly xAxis: Vector<0 | 1>;
     /**
-     * Creates a J2000 coordinate from classical elements.
-     * @param elements The classical elements.
-     * @returns The J2000 coordinate.
+     * Represents the y-axis vector.
      */
-    static fromClassicalElements(elements: ClassicalElements): J2000;
+    static readonly yAxis: Vector<0 | 1>;
     /**
-     * Gets the name of the coordinate system.
-     * @returns The name of the coordinate system.
+     * Represents the z-axis vector.
      */
-    get name(): string;
+    static readonly zAxis: Vector<0 | 1>;
     /**
-     * Gets a value indicating whether the coordinate system is inertial.
-     * @returns A boolean value indicating whether the coordinate system is inertial.
+     * Represents a vector pointing along the negative x-axis.
      */
-    get inertial(): boolean;
+    static readonly xAxisNeg: Vector<0 | -1>;
     /**
-     * Converts the coordinates from J2000 to the International Terrestrial Reference Frame (ITRF).
-     * This is an ECI to ECEF transformation.
-     * @returns The ITRF coordinates.
+     * Represents a vector pointing along the negative y-axis.
      */
-    toITRF(): ITRF;
+    static readonly yAxisNeg: Vector<0 | -1>;
     /**
-     * Converts the J2000 coordinate to the TEME coordinate.
-     * @returns The TEME coordinate.
+     * Represents a vector pointing along the negative z-axis.
      */
-    toTEME(): TEME;
-}
-
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * The International Terrestrial Reference Frame (ITRF) is a geocentric reference frame for the Earth. It is the
- * successor to the International Terrestrial Reference System (ITRS). The ITRF definition is maintained by the
- * International Earth Rotation and Reference Systems Service (IERS). Several versions of ITRF exist, each with a
- * different epoch, to address the issue of crustal motion. The latest version is ITRF2014, based on data collected from
- * 1980 to 2014.
- * @see https://en.wikipedia.org/wiki/International_Terrestrial_Reference_Frame
- *
- * This is a geocentric coordinate system, also referenced as ECF/ECEF (Earth Centered Earth Fixed). It is a Cartesian
- * coordinate system with the origin at the center of the Earth. The x-axis intersects the sphere of the Earth at 0°
- * latitude (the equator) and 0° longitude (the Prime Meridian). The z-axis goes through the North Pole. The y-axis goes
- * through 90° East longitude.
- * @see https://en.wikipedia.org/wiki/Earth-centered,_Earth-fixed_coordinate_system
- */
-declare class ITRF extends StateVector {
+    static readonly zAxisNeg: Vector<0 | -1>;
+    constructor(elements: T[] | Float64Array);
     /**
-     * Gets the name of the ITRF coordinate system.
-     * @returns The name of the coordinate system.
+     * Creates a zero vector of the specified length.
+     * @param length The length of the vector.
+     * @returns A new Vector object representing the zero vector.
      */
-    get name(): string;
+    static zero(length: number): Vector;
     /**
-     * Gets a value indicating whether the coordinate system is inertial.
-     * @returns A boolean value indicating whether the coordinate system is inertial.
+     * Creates a new Vector with the specified length, filled with the specified
+     * value.
+     * @param length The length of the new Vector.
+     * @param value The value to fill the Vector with.
+     * @returns A new Vector filled with the specified value.
      */
-    get inertial(): boolean;
+    static filled(length: number, value: number): Vector;
     /**
-     * Gets the height of the ITRF coordinate above the surface of the Earth in kilometers.
-     * @returns The height in kilometers.
+     * Creates a new Vector instance from an array of elements.
+     * @param elements - The array of elements to create the Vector from.
+     * @returns A new Vector instance.
      */
-    get height(): Kilometers;
+    static fromList(elements: number[]): Vector;
     /**
-     * Gets the altitude in kilometers.
-     * @returns The altitude in kilometers.
+     * Returns a string representation of the vector.
+     * @param fixed - The number of digits to appear after the decimal point.
+     * Defaults to -1.
+     * @returns A string representation of the vector.
      */
-    get alt(): Kilometers;
+    toString(fixed?: number): string;
     /**
-     * Converts the current coordinate to the J2000 coordinate system. This is an Earth-Centered Inertial (ECI) coordinate
-     * system with the origin at the center of the Earth.
-     * @see https://en.wikipedia.org/wiki/Epoch_(astronomy)#Julian_years_and_J2000
-     * @returns The coordinate in the J2000 coordinate system.
+     * Returns a string representation of the x value of the vector.
+     * @returns A string representation of the x value of the vector.
      */
-    toJ2000(): J2000;
+    get x(): number;
     /**
-     * Converts the current ITRF coordinate to Geodetic coordinate. This is a coordinate system for latitude, longitude,
-     * and altitude.
-     * @returns The converted Geodetic coordinate.
-     */
-    toGeodetic(): Geodetic;
-}
-
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * This Geodetic class represents a geodetic coordinate in three-dimensional
- * space, consisting of latitude, longitude, and altitude. It provides various
- * methods to perform calculations and operations related to geodetic
- * coordinates.
- *
- * This is a class for geodetic coordinates. This is related to the GroundObject
- * class, which is used to represent an object on the surface of the Earth.
- */
-declare class Geodetic {
-    readonly lat: Radians;
-    readonly lon: Radians;
-    readonly alt: Kilometers;
-    constructor(latitude: Radians, longitude: Radians, altitude: Kilometers);
+     * Returns a string representation of the y value of the vector.
+     * @returns A string representation of the y value of the vector.
+     */
+    get y(): number;
     /**
-     * Creates a Geodetic object from latitude, longitude, and altitude values in
-     * degrees.
-     * @param latitude The latitude value in degrees.
-     * @param longitude The longitude value in degrees.
-     * @param altitude The altitude value in kilometers.
-     * @returns A Geodetic object representing the specified latitude, longitude,
-     * and altitude.
+     * Returns a string representation of the z value of the vector.
+     * @returns A string representation of the z value of the vector.
      */
-    static fromDegrees(latitude: Degrees, longitude: Degrees, altitude: Kilometers): Geodetic;
+    get z(): number;
     /**
-     * Returns a string representation of the Geodetic object.
-     * @returns A string containing the latitude, longitude, and altitude of the Geodetic object.
+     * Converts the vector elements to an array.
+     * @returns An array containing the vector elements.
      */
-    toString(): string;
+    toList(): number[];
     /**
-     * Gets the latitude in degrees.
-     * @returns The latitude in degrees.
+     * Converts the vector to a Float64Array.
+     * @returns The vector as a Float64Array.
      */
-    get latDeg(): number;
+    toArray(): Float64Array;
     /**
-     * Gets the longitude in degrees.
-     * @returns The longitude in degrees.
+     * Calculates the magnitude of the vector.
+     * @returns The magnitude of the vector.
      */
-    get lonDeg(): number;
+    magnitude(): number;
     /**
-     * Converts the geodetic coordinates to a ground station.
-     * @returns The ground station object.
+     * Adds the elements of another vector to this vector and returns a new
+     * vector.
+     * @param v - The vector to add.
+     * @returns A new vector containing the sum of the elements.
      */
-    toGroundStation(): GroundStation;
+    add(v: Vector): Vector;
     /**
-     * Converts the geodetic coordinates to the International Terrestrial
-     * Reference Frame (ITRF) coordinates.
-     * @param epoch The epoch in UTC.
-     * @returns The ITRF coordinates.
+     * Subtracts a vector from the current vector.
+     * @param v The vector to subtract.
+     * @returns A new vector representing the result of the subtraction.
      */
-    toITRF(epoch: EpochUTC): ITRF;
+    subtract(v: Vector): Vector;
     /**
-     * Calculates the angle between two geodetic coordinates.
-     * @param g The geodetic coordinate to calculate the angle to.
-     * @param method The method to use for calculating the angular distance (optional, default is Haversine).
-     * @returns The angle between the two geodetic coordinates in radians.
+     * Scales the vector by a given factor.
+     * @param n The scaling factor.
+     * @returns A new Vector object representing the scaled vector.
      */
-    angle(g: Geodetic, method?: AngularDistanceMethod): Radians;
+    scale(n: number): Vector;
     /**
-     * Calculates the angle in degrees between two Geodetic coordinates.
-     * @param g The Geodetic coordinate to calculate the angle with.
-     * @param method The method to use for calculating the angular distance (optional, default is Haversine).
-     * @returns The angle in degrees.
+     * Negates the vector by scaling it by -1.
+     * @returns A new Vector object representing the negated vector.
      */
-    angleDeg(g: Geodetic, method?: AngularDistanceMethod): Degrees;
+    negate(): Vector;
     /**
-     * Calculates the distance between two geodetic coordinates.
-     * @param g The geodetic coordinates to calculate the distance to.
-     * @param method The method to use for calculating the angular distance. Default is Haversine.
-     * @returns The distance between the two geodetic coordinates in kilometers.
+     * Return the Euclidean distance between this and another Vector.
+     * @param v The vector to calculate the distance to.
+     * @returns The distance between the two vectors.
      */
-    distance(g: Geodetic, method?: AngularDistanceMethod): Kilometers;
+    distance(v: Vector): number;
     /**
-     * Calculates the field of view based on the altitude of the Geodetic object.
-     * @returns The field of view in radians.
+     * Normalizes the vector, making it a unit vector with the same direction but
+     * a magnitude of 1. If the vector has a magnitude of 0, it returns a zero
+     * vector of the same length.
+     * @returns The normalized vector.
      */
-    fieldOfView(): Radians;
+    normalize(): Vector;
     /**
-     * Determines if the current geodetic coordinate can see another geodetic coordinate.
-     * @param g The geodetic coordinate to check for visibility.
-     * @param method The method to use for calculating the angular distance (optional, default is Haversine).
-     * @returns A boolean indicating if the current coordinate can see the other coordinate.
+     * Calculates the dot product of this vector and another vector.
+     * @param v - The vector to calculate the dot product with.
+     * @returns The dot product of the two vectors.
      */
-    isInView(g: Geodetic, method?: AngularDistanceMethod): boolean;
+    dot(v: Vector): number;
+    /**
+     * Calculates the outer product of this vector with another vector.
+     * @param v The vector to calculate the outer product with.
+     * @returns A matrix representing the outer product of the two vectors.
+     */
+    outer(v: Vector): Matrix;
+    /**
+     * Calculates the cross product of this vector and the given vector.
+     * @param v - The vector to calculate the cross product with.
+     * @returns The resulting vector.
+     */
+    cross(v: Vector): Vector;
+    /**
+     * Calculate the skew-symmetric matrix for this [Vector].
+     * @returns The skew-symmetric matrix.
+     * @throws [Error] if the vector is not of length 3.
+     */
+    skewSymmetric(): Matrix;
+    /**
+     * Rotates the vector around the X-axis by the specified angle.
+     * @param theta The angle in radians.
+     * @returns The rotated vector.
+     */
+    rotX(theta: Radians): Vector;
+    /**
+     * Rotates the vector around the Y-axis by the specified angle.
+     * @param theta The angle of rotation in radians.
+     * @returns A new Vector representing the rotated vector.
+     */
+    rotY(theta: Radians): Vector;
+    /**
+     * Rotates the vector around the Z-axis by the specified angle.
+     * @param theta The angle of rotation in radians.
+     * @returns A new Vector representing the rotated vector.
+     */
+    rotZ(theta: Radians): Vector;
+    /**
+     * Calculates the angle between this vector and another vector.
+     * @param v The other vector.
+     * @returns The angle between the two vectors in radians.
+     */
+    angle(v: Vector): Radians;
+    /**
+     * Calculates the angle between this vector and another vector in degrees.
+     * @param v The other vector.
+     * @returns The angle between the two vectors in degrees.
+     */
+    angleDegrees(v: Vector): Degrees;
+    /**
+     * Determines if there is line of sight between this vector and another vector
+     * within a given radius.
+     * @param v - The vector to check line of sight with.
+     * @param radius - The radius within which line of sight is considered.
+     * @returns True if there is line of sight, false otherwise.
+     */
+    sight(v: Vector, radius: number): boolean;
+    /**
+     * Returns the bisect vector between this vector and the given vector. The
+     * bisect vector is calculated by scaling this vector's magnitude by the
+     * magnitude of the given vector, adding the result to the product of scaling
+     * the given vector's magnitude by this vector's magnitude, and then
+     * normalizing the resulting vector.
+     * @param v - The vector to calculate the bisect with.
+     * @returns The bisect vector.
+     */
+    bisect(v: Vector): Vector;
+    /**
+     * Joins the current vector with another vector.
+     * @param v The vector to join with.
+     * @returns A new vector that contains the elements of both vectors.
+     */
+    join(v: Vector): Vector;
+    /**
+     * Returns a new Vector containing a portion of the elements from the
+     * specified start index to the specified end index
+     * @param start The start index of the slice (inclusive).
+     * @param end The end index of the slice (exclusive).
+     * @returns A new Vector containing the sliced elements.
+     */
+    slice(start: number, end: number): Vector;
+    /**
+     * Returns a new Matrix object representing the row vector.
+     * @returns The row vector as a Matrix object.
+     */
+    row(): Matrix;
+    /**
+     * Returns a new Matrix object representing the column vector of this Vector.
+     * @returns The column vector as a Matrix object.
+     */
+    column(): Matrix;
+    /**
+     * Converts the elements at the specified index to a Vector3D object.
+     * @param index - The index of the elements to convert.
+     * @returns A new Vector3D object containing the converted elements.
+     */
+    toVector3D(index: number): Vector3D;
 }
 
 /**
@@ -1749,104 +1634,164 @@ declare class Geodetic {
  */
 
 /**
- * A class containing static methods for formatting TLEs (Two-Line Elements).
+ * A matrix is a rectangular array of numbers or other mathematical objects for
+ * which operations such as addition and multiplication are defined.
  */
-declare abstract class FormatTle {
-    private constructor();
+declare class Matrix {
+    elements: number[][];
+    readonly rows: number;
+    readonly columns: number;
+    constructor(elements: number[][]);
     /**
-     * Creates a TLE (Two-Line Element) string based on the provided TleParams.
-     * @param tleParams - The parameters used to generate the TLE.
-     * @returns An object containing the TLE strings tle1 and tle2.
+     * Creates a matrix with all elements set to zero.
+     * @param rows - The number of rows in the matrix.
+     * @param columns - The number of columns in the matrix.
+     * @returns A matrix with all elements set to zero.
      */
-    static createTle(tleParams: TleParams): {
-        tle1: TleLine1;
-        tle2: TleLine2;
-    };
+    static allZeros(rows: number, columns: number): Matrix;
     /**
-     * Converts the argument of perigee to a stringified number.
-     * @param argPe - The argument of perigee to be converted. Can be either a number or a string.
-     * @returns The argument of perigee as a stringified number.
-     * @throws Error if the length of the argument of perigee is not 8.
-     */
-    static argumentOfPerigee(argPe: number | string): StringifiedNumber;
+     * Creates a new Matrix with the specified number of rows and columns, filled
+     * with the specified value.
+     * @param rows The number of rows in the matrix.
+     * @param columns The number of columns in the matrix.
+     * @param value The value to fill the matrix with. Default is 0.0.
+     * @returns A new Matrix filled with the specified value.
+     */
+    static fill(rows: number, columns: number, value?: number): Matrix;
     /**
-     * Returns the eccentricity value formatted for TLE.
-     * @param ecen - The eccentricity value (string or number).
-     * @returns The eccentricity value formatted as 7 digits without leading "0.".
-     * @throws Error if the length of the eccentricity string is not 7.
+     * Creates a rotation matrix around the X-axis.
+     * @param theta - The angle of rotation in radians.
+     * @returns The rotation matrix.
      */
-    static eccentricity(ecen: string | number): string;
+    static rotX(theta: Radians): Matrix;
     /**
-     * Converts the inclination value to a string representation.
-     * @param inc - The inclination value to be converted.
-     * @returns The string representation of the inclination value.
-     * @throws Error if the length of the converted value is not 8.
+     * Creates a rotation matrix around the y-axis.
+     * @param theta - The angle of rotation in radians.
+     * @returns The rotation matrix.
      */
-    static inclination(inc: number | string): StringifiedNumber;
+    static rotY(theta: Radians): Matrix;
     /**
-     * Converts the mean anomaly to a string representation with 8 digits, padded with leading zeros.
-     * @param meana - The mean anomaly to be converted. Can be either a number or a string.
-     * @returns The mean anomaly as a string with 8 digits, padded with leading zeros.
-     * @throws Error if the length of the mean anomaly is not 8.
+     * Creates a rotation matrix around the Z-axis.
+     * @param theta The angle of rotation in radians.
+     * @returns The rotation matrix.
      */
-    static meanAnomaly(meana: number | string): StringifiedNumber;
+    static rotZ(theta: Radians): Matrix;
     /**
-     * Converts the mean motion value to a string representation with 8 decimal
-     * places. If the input is a number, it is converted to a string. If the input
-     * is already a string, it is parsed as a float and then converted to a string
-     * with 8 decimal places. The resulting string is padded with leading zeros to
-     * ensure a length of 11 characters. Throws an error if the resulting string
-     * does not have a length of 11 characters.
-     * @param meanmo - The mean motion value to be converted.
-     * @returns The string representation of the mean motion value with 8 decimal
-     * places and padded with leading zeros.
-     * @throws Error if the resulting string does not have a length of 11
-     * characters.
+     * Creates a zero matrix with the specified number of rows and columns.
+     * @param rows The number of rows in the matrix.
+     * @param columns The number of columns in the matrix.
+     * @returns A new Matrix object representing the zero matrix.
      */
-    static meanMotion(meanmo: number | string): StringifiedNumber;
+    static zero(rows: number, columns: number): Matrix;
     /**
-     * Converts the right ascension value to a stringified number.
-     * @param rasc - The right ascension value to convert.
-     * @returns The stringified number representation of the right ascension.
-     * @throws Error if the length of the converted right ascension is not 8.
+     * Creates an identity matrix of the specified dimension.
+     * @param dimension The dimension of the identity matrix.
+     * @returns The identity matrix.
      */
-    static rightAscension(rasc: number | string): StringifiedNumber;
+    static identity(dimension: number): Matrix;
     /**
-     * Sets a character at a specific index in a string. If the index is out of range, the original string is returned.
-     * @param str - The input string.
-     * @param index - The index at which to set the character.
-     * @param chr - The character to set at the specified index.
-     * @returns The modified string with the character set at the specified index.
+     * Creates a diagonal matrix with the given diagonal elements.
+     * @param d - An array of diagonal elements.
+     * @returns A new Matrix object representing the diagonal matrix.
      */
-    static setCharAt(str: string, index: number, chr: string): string;
+    static diagonal(d: number[]): Matrix;
     /**
-     * Format mean motion dot (first derivative / 2) for TLE line 1.
-     * Format: sign + ".NNNNNNNN" = 10 chars total.
-     * @param value - Mean motion dot value (rev/day^2)
-     * @returns Formatted 10-character string
+     * Adds the elements of another matrix to this matrix and returns the result.
+     * @param m - The matrix to be added.
+     * @returns The resulting matrix after addition.
      */
-    static formatMeanMotionDot(value: number): string;
+    add(m: Matrix): Matrix;
     /**
-     * Format a value in TLE exponential notation for BSTAR or mean motion ddot.
-     * Format: "sNNNNN±N" (8 chars) where mantissa has implied leading decimal point.
-     * Example: 0.00017507 → " 17507-3" (i.e., .17507 × 10^-3)
-     * @param value - The value to format
-     * @returns Formatted 8-character string
+     * Subtracts the elements of another matrix from this matrix.
+     * @param m - The matrix to subtract.
+     * @returns A new matrix containing the result of the subtraction.
      */
-    static formatTleExponential(value: number): string;
+    subtract(m: Matrix): Matrix;
     /**
-     * Compute TLE line checksum (modulo 10 sum of digits, '-' counts as 1).
-     * @param line - TLE line (first 68 characters are summed)
-     * @returns Checksum digit (0-9)
+     * Scales the matrix by multiplying each element by a scalar value.
+     * @param n - The scalar value to multiply each element by.
+     * @returns A new Matrix object representing the scaled matrix.
      */
-    static tleChecksum(line: string): number;
+    scale(n: number): Matrix;
+    /**
+     * Negates the matrix by scaling it by -1.
+     * @returns The negated matrix.
+     */
+    negate(): Matrix;
+    /**
+     * Multiplies this matrix with another matrix.
+     * @param m The matrix to multiply with.
+     * @returns The resulting matrix.
+     */
+    multiply(m: Matrix): Matrix;
+    /**
+     * Computes the outer product of this matrix with another matrix.
+     * @param m - The matrix to compute the outer product with.
+     * @returns The resulting matrix.
+     */
+    outerProduct(m: Matrix): Matrix;
+    /**
+     * Multiplies the matrix by a vector.
+     * @param v The vector to multiply by.
+     * @returns A new vector representing the result of the multiplication.
+     */
+    multiplyVector(v: Vector): Vector;
+    /**
+     * Multiplies a 3D vector by the matrix.
+     * @template T - The type of the vector elements.
+     * @param v - The 3D vector to multiply.
+     * @returns The resulting 3D vector after multiplication.
+     */
+    multiplyVector3D<T extends number>(v: Vector3D<T>): Vector3D<T>;
+    /**
+     * Returns a new Matrix object where each element is the reciprocal of the
+     * corresponding element in the current matrix. If an element in the current
+     * matrix is zero, the corresponding element in the output matrix will also be
+     * zero.
+     * @returns A new Matrix object representing the reciprocal of the current
+     * matrix.
+     */
+    reciprocal(): Matrix;
+    /**
+     * Transposes the matrix by swapping rows with columns.
+     * @returns A new Matrix object representing the transposed matrix.
+     */
+    transpose(): Matrix;
+    /**
+     * Performs the Cholesky decomposition on the matrix.
+     * @returns A new Matrix object representing the Cholesky decomposition of the
+     * original matrix.
+     */
+    cholesky(): Matrix;
+    /**
+     * Swaps two rows in the matrix.
+     * @param i - The index of the first row.
+     * @param j - The index of the second row.
+     */
+    private _swapRows;
+    /**
+     * Converts the matrix to reduced row echelon form using the Gaussian
+     * elimination method. This method modifies the matrix in-place.
+     */
+    private toReducedRowEchelonForm_;
+    /**
+     * Calculates the inverse of the matrix.
+     * @returns The inverse of the matrix.
+     */
+    inverse(): Matrix;
 }
 
 /**
  * @author Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
  * @license AGPL-3.0-or-later
  * @copyright (c) 2025-2026 Kruczek Labs LLC
  *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
  * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Affero General Public License as published by the Free Software
  * Foundation, either version 3 of the License, or (at your option) any later version.
@@ -1859,21 +1804,73 @@ declare abstract class FormatTle {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
-declare abstract class Force {
+declare class Vector3D<T extends number = number> {
+    x: T;
+    y: T;
+    z: T;
+    constructor(x: T, y: T, z: T);
     /**
-     * Calculate the acceleration due to the perturbing force on a given
-     * state vector.
-     * @param state The state vector.
-     * @throws If the force cannot be calculated.
+     * Create a new Vector3D object from the first three elements of a Vector
+     * object.
+     * @param v The Vector object to convert.
+     * @returns A new Vector3D object.
      */
-    abstract acceleration(state: J2000): Vector3D;
+    static fromVector<U extends number>(v: Vector<U>): Vector3D<U>;
+    static readonly origin: Vector3D<number>;
+    static readonly xAxis: Vector3D<number>;
+    static readonly yAxis: Vector3D<number>;
+    static readonly zAxis: Vector3D<number>;
+    static readonly xAxisNeg: Vector3D<number>;
+    static readonly yAxisNeg: Vector3D<number>;
+    static readonly zAxisNeg: Vector3D<number>;
+    toList(): T[];
+    toArray(): Float64Array<ArrayBuffer>;
+    toVector(): Vector<T>;
+    toString(fixed?: number): string;
+    magnitude(): T;
+    add(v: Vector3D<T>): Vector3D<T>;
+    subtract(v: Vector3D<T>): Vector3D<T>;
+    scale<U extends number>(n: U): Vector3D<U>;
+    negate(): Vector3D<T>;
+    /**
+     * Return the Euclidean distance between this and another Vector3D.
+     * @param v The other Vector3D.
+     * @returns The distance between this and the other Vector3D.
+     */
+    distance(v: Vector3D<T>): T;
+    /**
+     * Convert this to a unit Vector3D.
+     * @returns A unit Vector3D.
+     */
+    normalize(): Vector3D<T>;
+    dot<T extends number>(v: Vector3D<T>): T;
+    outer(v: Vector3D): Matrix;
+    cross<U extends number>(v: Vector3D<U>): Vector3D<U>;
+    skewSymmetric(): Matrix;
+    rotX(theta: number): Vector3D;
+    rotY(theta: Radians): Vector3D<T>;
+    rotZ(theta: Radians): Vector3D<T>;
+    angle<U extends number>(v: Vector3D<U>): Radians;
+    angleDegrees(v: Vector3D<T>): number;
+    sight(v: Vector3D<KilometersPerSecond>, radius: Kilometers): boolean;
+    bisect(v: Vector3D<T>): Vector3D<T>;
+    row(): Matrix;
+    column(): Matrix;
+    join(v: Vector3D): Vector;
+    static readonly zero: Vector3D<number>;
 }
 
 /**
  * @author Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
  * @license AGPL-3.0-or-later
  * @copyright (c) 2025-2026 Kruczek Labs LLC
  *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
  * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Affero General Public License as published by the Free Software
  * Foundation, either version 3 of the License, or (at your option) any later version.
@@ -1886,78 +1883,191 @@ declare abstract class Force {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
-declare class Thrust implements Force {
-    center: EpochUTC;
-    radial: MetersPerSecond;
-    intrack: MetersPerSecond;
-    crosstrack: MetersPerSecond;
-    durationRate: SecondsPerMeterPerSecond;
-    constructor(center: EpochUTC, radial: MetersPerSecond, intrack: MetersPerSecond, crosstrack: MetersPerSecond, durationRate?: SecondsPerMeterPerSecond);
-    deltaV: Vector3D<KilometersPerSecond>;
-    get magnitude(): MetersPerSecond;
-    get duration(): Seconds;
-    get start(): EpochUTC;
-    get stop(): EpochUTC;
-    acceleration(state: J2000): Vector3D;
-    apply(state: J2000): J2000;
-    get isImpulsive(): boolean;
-}
-
 /**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ * A state vector is a set of coordinates used to specify the position and
+ * velocity of an object in a particular reference frame.
  */
-
-declare abstract class Interpolator {
-    abstract window(): EpochWindow;
-    inWindow(epoch: EpochUTC): boolean;
-    overlap(interpolator: Interpolator): EpochWindow | null;
+declare abstract class StateVector {
+    epoch: EpochUTC;
+    position: Vector3D<Kilometers>;
+    velocity: Vector3D<KilometersPerSecond>;
+    constructor(epoch: EpochUTC, position: Vector3D<Kilometers>, velocity: Vector3D<KilometersPerSecond>);
+    /**
+     * The name of the reference frame in which the state vector is defined.
+     * @returns The name of the reference frame.
+     */
+    abstract get name(): string;
+    /**
+     * Whether the state vector is defined in an inertial reference frame.
+     * @returns True if the state vector is defined in an inertial reference
+     */
+    abstract get inertial(): boolean;
+    /**
+     * Returns a string representation of the StateVector object. The string includes the name, epoch, position, and
+     * velocity.
+     * @returns A string representation of the StateVector object.
+     */
+    toString(): string;
+    /**
+     * Calculates the mechanical energy of the state vector.
+     * @returns The mechanical energy value.
+     */
+    get mechanicalEnergy(): number;
+    /**
+     * Calculates the semimajor axis of the state vector.
+     * @returns The semimajor axis in kilometers.
+     */
+    get semimajorAxis(): Kilometers;
+    /**
+     * Gets the period of the state vector in minutes.
+     * @returns The period in minutes.
+     */
+    get period(): Minutes;
+    /**
+     * Gets the angular rate of the state vector.
+     * @returns The angular rate.
+     */
+    get angularRate(): number;
+    /**
+     * Converts the state vector to classical elements.
+     * @param mu The gravitational parameter of the celestial body. Defaults to Earth's gravitational parameter.
+     * @returns The classical elements corresponding to the state vector.
+     * @throws Error if classical elements are undefined for fixed frames.
+     */
+    toClassicalElements(mu?: number): ClassicalElements;
 }
-
 /**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
+ * Represents a position and velocity in the J2000 coordinate system. This is an Earth-centered inertial (ECI)
+ * coordinate system.
  *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
+ * Commonly used ECI frame is defined with the Earth's Mean Equator and Mean Equinox (MEME) at 12:00 Terrestrial Time on
+ * 1 January 2000. It can be referred to as J2K, J2000 or EME2000. The x-axis is aligned with the mean vernal equinox.
+ * The z-axis is aligned with the Earth's rotation axis (or equivalently, the celestial North Pole) as it was at that
+ * time. The y-axis is rotated by 90° East about the celestial equator.
+ * @see https://en.wikipedia.org/wiki/Earth-centered_inertial
+ */
+declare class J2000 extends StateVector {
+    /**
+     * Creates a J2000 coordinate from classical elements.
+     * @param elements The classical elements.
+     * @returns The J2000 coordinate.
+     */
+    static fromClassicalElements(elements: ClassicalElements): J2000;
+    /**
+     * Gets the name of the coordinate system.
+     * @returns The name of the coordinate system.
+     */
+    get name(): string;
+    /**
+     * Gets a value indicating whether the coordinate system is inertial.
+     * @returns A boolean value indicating whether the coordinate system is inertial.
+     */
+    get inertial(): boolean;
+    /**
+     * Converts the coordinates from J2000 to the International Terrestrial Reference Frame (ITRF).
+     * This is an ECI to ECEF transformation.
+     * @returns The ITRF coordinates.
+     */
+    toITRF(): ITRF;
+    /**
+     * Converts the J2000 coordinate to the TEME coordinate.
+     * @returns The TEME coordinate.
+     */
+    toTEME(): TEME;
+}
+/**
+ * The International Terrestrial Reference Frame (ITRF) is a geocentric reference frame for the Earth. It is the
+ * successor to the International Terrestrial Reference System (ITRS). The ITRF definition is maintained by the
+ * International Earth Rotation and Reference Systems Service (IERS). Several versions of ITRF exist, each with a
+ * different epoch, to address the issue of crustal motion. The latest version is ITRF2014, based on data collected from
+ * 1980 to 2014.
+ * @see https://en.wikipedia.org/wiki/International_Terrestrial_Reference_Frame
  *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
+ * This is a geocentric coordinate system, also referenced as ECF/ECEF (Earth Centered Earth Fixed). It is a Cartesian
+ * coordinate system with the origin at the center of the Earth. The x-axis intersects the sphere of the Earth at 0°
+ * latitude (the equator) and 0° longitude (the Prime Meridian). The z-axis goes through the North Pole. The y-axis goes
+ * through 90° East longitude.
+ * @see https://en.wikipedia.org/wiki/Earth-centered,_Earth-fixed_coordinate_system
+ */
+declare class ITRF extends StateVector {
+    /**
+     * Gets the name of the ITRF coordinate system.
+     * @returns The name of the coordinate system.
+     */
+    get name(): string;
+    /**
+     * Gets a value indicating whether the coordinate system is inertial.
+     * @returns A boolean value indicating whether the coordinate system is inertial.
+     */
+    get inertial(): boolean;
+    /**
+     * Gets the height of the ITRF coordinate above the surface of the Earth in kilometers.
+     * @returns The height in kilometers.
+     */
+    get height(): Kilometers;
+    /**
+     * Gets the altitude in kilometers.
+     * @returns The altitude in kilometers.
+     */
+    get alt(): Kilometers;
+    /**
+     * Converts the current coordinate to the J2000 coordinate system. This is an Earth-Centered Inertial (ECI) coordinate
+     * system with the origin at the center of the Earth.
+     * @see https://en.wikipedia.org/wiki/Epoch_(astronomy)#Julian_years_and_J2000
+     * @returns The coordinate in the J2000 coordinate system.
+     */
+    toJ2000(): J2000;
+    /**
+     * Converts the current ITRF coordinate to Geodetic coordinate. This is a coordinate system for latitude, longitude,
+     * and altitude.
+     * @returns The converted Geodetic coordinate.
+     */
+    toGeodetic(): Geodetic;
+}
+/**
+ * True Equator Mean Equinox (TEME) is a coordinate system commonly used in satellite tracking and orbit prediction. It
+ * is a reference frame that defines the position and orientation of an object relative to the Earth's equator and
+ * equinox.
  *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ * By using the True Equator Mean Equinox (TEME) coordinate system, we can accurately describe the position and motion
+ * of satellites relative to the Earth's equator and equinox. This is particularly useful for tracking and predicting
+ * satellite orbits in various applications, such as satellite communication, navigation, and remote sensing.
  */
-
-declare abstract class StateInterpolator extends Interpolator {
+declare class TEME extends StateVector {
     /**
-     * Interpolates the state at the given epoch.
-     * @param epoch The epoch in UTC format.
-     * @throws If the interpolator has not been initialized.
+     * Gets the name of the coordinate system.
+     * @returns The name of the coordinate system.
      */
-    abstract interpolate(epoch: EpochUTC): J2000 | null;
-    get sizeBytes(): number;
+    get name(): string;
+    /**
+     * Gets a value indicating whether the coordinate is inertial.
+     * @returns A boolean value indicating whether the coordinate is inertial.
+     */
+    get inertial(): boolean;
+    /**
+     * Creates a TEME (True Equator Mean Equinox) object from classical orbital elements.
+     * @param elements - The classical orbital elements.
+     * @returns A new TEME object.
+     */
+    static fromClassicalElements(elements: ClassicalElements): TEME;
+    /**
+     * Converts the TEME (True Equator Mean Equinox) coordinates to J2000 coordinates.
+     * @returns The J2000 coordinates.
+     */
+    toJ2000(): J2000;
 }
 
 /**
  * @author Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
  * @license AGPL-3.0-or-later
  * @copyright (c) 2025-2026 Kruczek Labs LLC
  *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
  * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Affero General Public License as published by the Free Software
  * Foundation, either version 3 of the License, or (at your option) any later version.
@@ -1970,32 +2080,12 @@ declare abstract class StateInterpolator extends Interpolator {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
-declare class ForceModel {
-    private centralGravity_?;
-    private thirdBodyGravity_?;
-    private solarRadiationPressure_?;
-    private atmosphericDrag_?;
-    private maneuverThrust_;
-    setGravity(mu?: number): this;
-    setEarthGravity(degree: number, order: number): void;
-    setThirdBodyGravity({ moon, sun }: {
-        moon?: boolean | undefined;
-        sun?: boolean | undefined;
-    }): void;
-    setSolarRadiationPressure(mass: number, area: number, coeff?: number): void;
-    /**
-     * Sets the atmospheric drag for the force model.
-     * @deprecated This is still a work in progress!
-     * @param mass - The mass of the object.
-     * @param area - The cross-sectional area of the object.
-     * @param coeff - The drag coefficient. Default value is 2.2.
-     * @param cosine - The cosine of the angle between the object's velocity vector and the drag force vector.
-     */
-    setAtmosphericDrag(mass: number, area: number, coeff?: number, cosine?: number): void;
-    loadManeuver(maneuver: Thrust): void;
-    clearManeuver(): void;
-    acceleration(state: J2000): Vector3D;
-    derivative(state: J2000): Vector;
+interface BaseObjectParams {
+    id?: number;
+    name?: string;
+    type?: SpaceObjectType;
+    active?: boolean;
+    metadata?: Record<string, unknown>;
 }
 
 /**
@@ -2014,77 +2104,90 @@ declare class ForceModel {
  * You should have received a copy of the GNU Affero General Public License along with
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
-
-declare class Waypoint {
-    epoch: EpochUTC;
-    relativePosition: Vector3D<Kilometers>;
-    constructor(epoch: EpochUTC, relativePosition: Vector3D<Kilometers>);
-    /**
-     * Return the perturbed error in a [maneuver] when compared against the
-     * target [waypoint] given an initial [state], [forceModel],
-     * [target] interpolator, and speculative relative maneuver
-     * [components] _(m/s)_.
-     * @param waypoint The waypoint to target.
-     * @param maneuver The maneuver to perturb.
-     * @param state The initial state of the interceptor.
-     * @param forceModel The force model to use for propagation.
-     * @param target The target interpolator.
-     * @param components The speculative maneuver components.
-     * @returns The perturbed error in the maneuver.
-     */
-    static _error(waypoint: Waypoint, maneuver: Thrust, state: J2000, forceModel: ForceModel, target: StateInterpolator, components: Float64Array): number;
-    /**
-     * Generate a score function for refining perturbed [waypoint] maneuvers.
-     *
-     * The score function takes an array of speculative radial, intrack, and
-     * crosstrack components _(m/s)_ and returns the propagated error from the
-     * desired waypoint target.
-     * @param waypoint The waypoint to target.
-     * @param maneuver The maneuver to perturb.
-     * @param state The initial state of the interceptor.
-     * @param forceModel The force model to use for propagation.
-     * @param target The target interpolator.
-     * @returns A score function for refining maneuvers.
+/**
+ * Configuration options for history tracking.
+ */
+interface HistoryConfig {
+    /** Maximum number of entries to store. Undefined means unlimited. */
+    maxLength?: number;
+    /** Minimum time between samples in milliseconds. */
+    samplingInterval?: number;
+    /** If true, automatically removes oldest entries when maxLength is reached. */
+    autoClean?: boolean;
+}
+/**
+ * A single entry in the history.
+ */
+interface HistoryEntry<T> {
+    time: Date;
+    data: T;
+}
+/**
+ * Generic history tracking class for storing time-stamped data.
+ * Used to track object state over time for visualization and analysis.
+ */
+declare class History<T> {
+    private entries_;
+    private config_;
+    private lastSampleTime_;
+    constructor(config?: HistoryConfig);
+    /**
+     * Adds a new entry to the history.
+     * Respects sampling interval and max length constraints.
+     * @param time - The timestamp for this entry
+     * @param data - The data to store
      */
-    static _refineManeuverScore(waypoint: Waypoint, maneuver: Thrust, state: J2000, forceModel: ForceModel, target: StateInterpolator): (components: Float64Array) => number;
+    add(time: Date, data: T): void;
     /**
-     * Convert an array of [waypoints] into a maneuver sequence given an
-     * [interceptor] state, [pivot] epoch for the first burn to arrive at the
-     * first waypoint, and [target] ephemeris interpolator.
-     *
-     * Optional arguments are as follows:
-     *  - `preManeuvers`: maneuvers to execute before the pivot burn
-     * - `postManeuvers`: maneuvers to execute after the last pivot burn
-     * - `durationRate`: thruster duration rate _(s/m/s)_
-     * - `forceModel`: interceptor force model, defaults to two-body
-     * - `refine`: refine maneuvers to account for perturbations if `true`
-     * - `maxIter`: maximum refinement iterations per maneuver
-     * - `printIter`: print debug information on each refinement iteration
-     * @param interceptor The interceptor state.
-     * @param pivot The epoch of the first burn.
-     * @param waypoints The waypoints to target.
-     * @param target The target interpolator.
-     * @param preManeuvers The maneuvers to execute before the pivot burn.
-     * @param postManeuvers The maneuvers to execute after the last pivot burn.
-     * @param root0 The optional arguments.
-     * @param root0.durationRate The thruster duration rate.
-     * @param root0.forceModel The interceptor force model.
-     * @param root0.refine Whether to refine maneuvers to account for perturbations.
-     * @param root0.maxIter The maximum refinement iterations per maneuver.
-     * @param root0.printIter Whether to print debug information on each refinement iteration.
-     * @returns An array of maneuvers.
+     * Returns all history entries.
      */
-    static toManeuvers(interceptor: J2000, pivot: EpochUTC, waypoints: Waypoint[], target: StateInterpolator, preManeuvers: Thrust[] | null, postManeuvers: Thrust[] | null, { durationRate, forceModel, refine, maxIter, printIter, }?: {
-        durationRate?: number;
-        forceModel?: ForceModel;
-        refine?: boolean;
-        maxIter?: number;
-        printIter?: boolean;
-    }): Thrust[];
-    static _refineManeuvers(waypoints: Waypoint[], maneuvers: Thrust[], interceptor: J2000, forceModel: ForceModel, target: StateInterpolator, { maxIter, printIter, }?: {
-        maxIter?: number;
-        printIter?: boolean;
-    }): Thrust[];
+    getAll(): HistoryEntry<T>[];
+    /**
+     * Returns entries within a time range (inclusive).
+     * @param start - Start of the time range
+     * @param end - End of the time range
+     */
+    getRange(start: Date, end: Date): HistoryEntry<T>[];
+    /**
+     * Returns the last n entries.
+     * @param n - Number of entries to return
+     */
+    getLast(n: number): HistoryEntry<T>[];
+    /**
+     * Returns the first entry, or undefined if empty.
+     */
+    getFirst(): HistoryEntry<T> | undefined;
+    /**
+     * Returns the most recent entry, or undefined if empty.
+     */
+    getLatest(): HistoryEntry<T> | undefined;
+    /**
+     * Clears all history entries.
+     */
+    clear(): void;
+    /**
+     * Creates a deep copy of this history.
+     * @returns A new History instance with cloned entries
+     */
+    clone(): History<T>;
+    /**
+     * Returns the number of entries in the history.
+     */
+    get length(): number;
+    /**
+     * Returns the current configuration.
+     */
+    get config(): HistoryConfig;
+    /**
+     * Returns true if the history is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Returns the time span covered by the history in milliseconds.
+     * Returns 0 if there are fewer than 2 entries.
+     */
+    get timeSpan(): number;
+    toString(): string;
 }
 
 /**
@@ -2104,35 +2207,44 @@ declare class Waypoint {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
-declare class Hill {
-    epoch: EpochUTC;
-    position: Vector3D<Kilometers>;
-    velocity: Vector3D<KilometersPerSecond>;
-    private semimajorAxis_;
-    private meanMotion_;
-    constructor(epoch: EpochUTC, position: Vector3D<Kilometers>, velocity: Vector3D<KilometersPerSecond>, semimajorAxis: Kilometers);
-    static fromState(origin: J2000, radialPosition: Kilometers, intrackPosition: Kilometers, nodeVelocity: KilometersPerSecond, nodeOffsetTime: Seconds): Hill;
-    static fromNmc(origin: J2000, majorAxisRange: Kilometers, nodeVelocity: KilometersPerSecond, nodeOffsetTime: Seconds, translation?: number): Hill;
-    static fromPerch(origin: J2000, perchRange: Kilometers, nodeVelocity: KilometersPerSecond, nodeOffsetTime: Seconds): Hill;
-    get semimajorAxis(): Kilometers;
-    set semimajorAxis(sma: Kilometers);
-    get meanMotion(): RadiansPerSecond;
-    toJ2000Matrix(origin: J2000, transform: Matrix): J2000;
-    toJ2000(origin: J2000): J2000;
-    static transitionMatrix(t: number, meanMotion: number): Matrix;
-    transition(t: Seconds): Hill;
-    transitionWithMatrix(stm: Matrix, t: Seconds): Hill;
-    propagate(newEpoch: EpochUTC): Hill;
-    propagateWithMatrix(stm: Matrix, newEpoch: EpochUTC): Hill;
-    maneuver(maneuver: Thrust): Hill;
-    ephemeris(start: EpochUTC, stop: EpochUTC, step?: Seconds): Hill[];
-    get period(): Seconds;
-    nextRadialTangent(): Hill;
-    solveManeuver(waypoint: Waypoint, ignoreCrosstrack?: boolean): Thrust;
-    maneuverSequence(pivot: EpochUTC, waypoints: Waypoint[], preManeuvers?: Thrust[], postManeuvers?: Thrust[]): Thrust[];
-    maneuverOrigin(maneuver: Thrust): Hill;
-    get name(): string;
-    toString(): string;
+/**
+ * State data that can be recorded in history.
+ */
+interface HistoricalState {
+    position: TemeVec3;
+    velocity: TemeVec3<KilometersPerSecond>;
+}
+/**
+ * Serialized representation of a BaseObject.
+ * Used for persistence and data transfer.
+ */
+interface SerializedObject {
+    /** The class name of the object */
+    type: string;
+    /** Unique identifier */
+    id: number;
+    /** Human-readable name */
+    name: string;
+    /** Additional type-specific data */
+    [key: string]: unknown;
+}
+/**
+ * Placeholder interface for sensors (will be defined in Phase 2).
+ * This allows SpaceObject and GroundObject to reference sensors
+ * without creating circular dependencies.
+ */
+interface SensorInterface {
+    id: number;
+    name: string;
+}
+/**
+ * Placeholder interface for communication devices (will be defined in Phase 3).
+ * This allows SpaceObject and GroundObject to reference comm devices
+ * without creating circular dependencies.
+ */
+interface CommunicationDeviceInterface {
+    id: number;
+    name: string;
 }
 
 /**
@@ -2158,60 +2270,97 @@ declare class Hill {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
-declare class Vector3D<T extends number = number> {
-    x: T;
-    y: T;
-    z: T;
-    constructor(x: T, y: T, z: T);
+/**
+ * Abstract base class for all objects in the ootk system.
+ * Provides common functionality for identification, type checking,
+ * history tracking, and serialization.
+ */
+declare abstract class BaseObject {
+    /** Unique identifier for the object */
+    id: number;
+    /** Human-readable name */
+    name: string;
+    /** Type classification of the object */
+    type: SpaceObjectType;
+    /** Whether the object is currently active */
+    active: boolean;
+    /** Additional metadata for the object */
+    metadata?: Record<string, unknown>;
+    /** History tracking (null until enabled) */
+    private history_;
+    constructor(info: BaseObjectParams);
     /**
-     * Create a new Vector3D object from the first three elements of a Vector
-     * object.
-     * @param v The Vector object to convert.
-     * @returns A new Vector3D object.
+     * Enables history tracking for this object.
+     * @param config - Optional configuration for history behavior
      */
-    static fromVector<U extends number>(v: Vector<U>): Vector3D<U>;
-    static readonly origin: Vector3D<number>;
-    static readonly xAxis: Vector3D<number>;
-    static readonly yAxis: Vector3D<number>;
-    static readonly zAxis: Vector3D<number>;
-    static readonly xAxisNeg: Vector3D<number>;
-    static readonly yAxisNeg: Vector3D<number>;
-    static readonly zAxisNeg: Vector3D<number>;
-    toList(): T[];
-    toArray(): Float64Array<ArrayBuffer>;
-    toVector(): Vector<T>;
-    toString(fixed?: number): string;
-    magnitude(): T;
-    add(v: Vector3D<T>): Vector3D<T>;
-    subtract(v: Vector3D<T>): Vector3D<T>;
-    scale<U extends number>(n: U): Vector3D<U>;
-    negate(): Vector3D<T>;
+    enableHistory(config?: HistoryConfig): void;
     /**
-     * Return the Euclidean distance between this and another Vector3D.
-     * @param v The other Vector3D.
-     * @returns The distance between this and the other Vector3D.
+     * Disables history tracking and clears existing history.
      */
-    distance(v: Vector3D<T>): T;
+    disableHistory(): void;
     /**
-     * Convert this to a unit Vector3D.
-     * @returns A unit Vector3D.
+     * Returns the history object if enabled, null otherwise.
      */
-    normalize(): Vector3D<T>;
-    dot<T extends number>(v: Vector3D<T>): T;
-    outer(v: Vector3D): Matrix;
-    cross<U extends number>(v: Vector3D<U>): Vector3D<U>;
-    skewSymmetric(): Matrix;
-    rotX(theta: number): Vector3D;
-    rotY(theta: Radians): Vector3D<T>;
-    rotZ(theta: Radians): Vector3D<T>;
-    angle<U extends number>(v: Vector3D<U>): Radians;
-    angleDegrees(v: Vector3D<T>): number;
-    sight(v: Vector3D<KilometersPerSecond>, radius: Kilometers): boolean;
-    bisect(v: Vector3D<T>): Vector3D<T>;
-    row(): Matrix;
-    column(): Matrix;
-    join(v: Vector3D): Vector;
-    static readonly zero: Vector3D<number>;
+    get history(): History<HistoricalState> | null;
+    /**
+     * Returns true if history tracking is enabled.
+     */
+    get isHistoryEnabled(): boolean;
+    /**
+     * Records a state to history if history tracking is enabled.
+     * @param time - The timestamp for this state
+     * @param state - The state to record
+     */
+    protected recordToHistory(time: Date, state: HistoricalState): void;
+    /**
+     * Serializes the object to a plain object for persistence.
+     */
+    serialize(): SerializedObject;
+    /**
+     * Returns type-specific serialization data.
+     * Subclasses must implement this to add their specific properties.
+     */
+    protected abstract serializeSpecific(): Record<string, unknown>;
+    /**
+     * Checks if the object is a satellite.
+     * @returns True if the object is a satellite, false otherwise.
+     */
+    isSatellite(): boolean;
+    /**
+     * Checks if the object is a ground object.
+     * @returns True if the object is a ground object, false otherwise.
+     */
+    isGroundObject(): boolean;
+    /**
+     * Returns whether the object is a sensor.
+     * @returns True if the object is a sensor, false otherwise.
+     */
+    isSensor(): boolean;
+    /**
+     * Checks if the object is a marker.
+     * @returns True if the object is a marker, false otherwise.
+     */
+    isMarker(): boolean;
+    /**
+     * Returns whether the object's position is static.
+     * @returns True if the object is static, false otherwise.
+     */
+    isStatic(): boolean;
+    isPayload(): boolean;
+    isRocketBody(): boolean;
+    isDebris(): boolean;
+    isStar(): boolean;
+    isMissile(): boolean;
+    isNotional(): boolean;
+    getTypeString(): string;
+    /**
+     * Validates a parameter value against a minimum and maximum value.
+     * @param value - The value to be validated.
+     * @param minValue - The minimum allowed value.
+     * @param maxValue - The maximum allowed value.
+     * @param errorMessage - The error message to be thrown if the value is invalid.
+     */
+    validateParameter<T>(value: T, minValue: T | null, maxValue: T | null, errorMessage: string): void;
 }
 
 /**
@@ -2238,243 +2387,268 @@ declare class Vector3D<T extends number = number> {
  */
 
 /**
- * A Vector is a mathematical object that has both magnitude and direction.
+ * Parameters for constructing a GroundObject.
  */
-declare class Vector<T extends number = number> {
-    elements: T[] | Float64Array;
-    /**
-     * The length of the vector.
-     */
-    readonly length: number;
-    /**
-     * Represents a 3-dimensional vector.
-     */
-    static readonly origin3: Vector<0>;
-    /**
-     * Represents a vector with all elements set to zero.
-     */
-    static readonly origin6: Vector<0>;
+interface GroundObjectParams extends BaseObjectParams {
+    lat: Degrees;
+    lon: Degrees;
+    alt: Kilometers;
+}
+/**
+ * Abstract base class for all objects on Earth's surface.
+ * Provides coordinate conversion methods and component attachment capabilities.
+ */
+declare abstract class GroundObject extends BaseObject {
+    name: string;
+    readonly lat: Degrees;
+    readonly lon: Degrees;
+    readonly alt: Kilometers;
+    /** Sensors attached to this ground object */
+    sensors: SensorInterface[];
+    /** Communication devices attached to this ground object */
+    commDevices: CommunicationDeviceInterface[];
+    constructor(info: GroundObjectParams);
     /**
-     * Represents the x-axis vector.
+     * Calculates the relative azimuth, elevation, and range between this GroundObject and a Satellite.
+     * @param satellite The Satellite object.
+     * @param date The date for which to calculate the RAE values. Defaults to the current date.
+     * @returns The relative azimuth, elevation, and range values in kilometers and degrees.
      */
-    static readonly xAxis: Vector<0 | 1>;
+    rae(satellite: Satellite, date?: Date): RaeVec3<Kilometers, Degrees> | null;
     /**
-     * Represents the y-axis vector.
+     * Calculates ECEF position at a given time.
+     * @variation optimized version of this.toGeodetic().toITRF().position;
+     * @returns The ECEF position vector of the ground object.
      */
-    static readonly yAxis: Vector<0 | 1>;
+    ecef(): EcefVec3<Kilometers>;
     /**
-     * Represents the z-axis vector.
+     * Calculates the Earth-Centered Inertial (ECI) position vector of the ground object at a given date.
+     * @variation optimized version of this.toGeodetic().toITRF().toJ2000().position;
+     * @param date The date for which to calculate the ECI position vector. Defaults to the current date.
+     * @returns The ECI position vector of the ground object.
      */
-    static readonly zAxis: Vector<0 | 1>;
+    eci(date?: Date): TemeVec3<Kilometers>;
     /**
-     * Represents a vector pointing along the negative x-axis.
+     * Returns the latitude, longitude, and altitude of the GroundObject.
+     * @returns The latitude, longitude, and altitude as an LlaVec3 object.
      */
-    static readonly xAxisNeg: Vector<0 | -1>;
+    lla(): LlaVec3<Degrees, Kilometers>;
     /**
-     * Represents a vector pointing along the negative y-axis.
+     * Converts the latitude, longitude, and altitude of the GroundObject to radians and kilometers.
+     * @variation optimized version of this.toGeodetic() without class instantiation for better performance and
+     * serialization.
+     * @returns An object containing the latitude, longitude, and altitude in radians and kilometers.
      */
-    static readonly yAxisNeg: Vector<0 | -1>;
+    llaRad(): LlaVec3<Radians, Kilometers>;
+    get latRad(): Radians;
+    get lonRad(): Radians;
     /**
-     * Represents a vector pointing along the negative z-axis.
+     * Converts the ground position to geodetic coordinates.
+     * @returns The geodetic coordinates.
      */
-    static readonly zAxisNeg: Vector<0 | -1>;
-    constructor(elements: T[] | Float64Array);
+    toGeodetic(): Geodetic;
     /**
-     * Creates a zero vector of the specified length.
-     * @param length The length of the vector.
-     * @returns A new Vector object representing the zero vector.
+     * Converts the ground position to J2000 inertial coordinates.
+     * Ground objects have zero velocity in the inertial frame (ignoring Earth rotation).
+     * @param date - The date for the conversion (defaults to now)
+     * @returns J2000 state vector
      */
-    static zero(length: number): Vector;
+    toJ2000(date?: Date): J2000;
     /**
-     * Creates a new Vector with the specified length, filled with the specified
-     * value.
-     * @param length The length of the new Vector.
-     * @param value The value to fill the Vector with.
-     * @returns A new Vector filled with the specified value.
+     * Adds a sensor to this ground object.
+     * @param sensor - The sensor to add
      */
-    static filled(length: number, value: number): Vector;
+    addSensor(sensor: SensorInterface): void;
     /**
-     * Creates a new Vector instance from an array of elements.
-     * @param elements - The array of elements to create the Vector from.
-     * @returns A new Vector instance.
+     * Removes a sensor from this ground object.
+     * @param sensorId - The ID of the sensor to remove
      */
-    static fromList(elements: number[]): Vector;
+    removeSensor(sensorId: number): void;
     /**
-     * Returns a string representation of the vector.
-     * @param fixed - The number of digits to appear after the decimal point.
-     * Defaults to -1.
-     * @returns A string representation of the vector.
+     * Adds a communication device to this ground object.
+     * @param device - The device to add
      */
-    toString(fixed?: number): string;
+    addCommDevice(device: CommunicationDeviceInterface): void;
     /**
-     * Returns a string representation of the x value of the vector.
-     * @returns A string representation of the x value of the vector.
+     * Removes a communication device from this ground object.
+     * @param deviceId - The ID of the device to remove
      */
-    get x(): number;
+    removeCommDevice(deviceId: number): void;
+    isGroundObject(): boolean;
     /**
-     * Returns a string representation of the y value of the vector.
-     * @returns A string representation of the y value of the vector.
+     * Validates the input data for the GroundObject.
+     * @param info - The GroundPositionParams object containing the latitude,
+     * longitude, and altitude.
      */
-    get y(): number;
+    private validateGroundObjectInputData_;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Parameters for constructing a GroundStation.
+ */
+interface GroundStationParams extends GroundObjectParams {
+}
+/**
+ * A concrete ground station that can host sensors and communication devices.
+ * Use this class for fixed ground locations like tracking stations, observatories, etc.
+ */
+declare class GroundStation extends GroundObject {
+    constructor(info: GroundStationParams);
     /**
-     * Returns a string representation of the z value of the vector.
-     * @returns A string representation of the z value of the vector.
+     * Creates a GroundStation from a Geodetic position.
+     * @param geodetic - The geodetic coordinates
+     * @param name - Optional name for the station
+     * @param id - Optional unique identifier
      */
-    get z(): number;
+    static fromGeodetic(geodetic: Geodetic, name?: string, id?: number): GroundStation;
     /**
-     * Converts the vector elements to an array.
-     * @returns An array containing the vector elements.
+     * Creates a deep copy of this ground station.
      */
-    toList(): number[];
+    clone(): GroundStation;
     /**
-     * Converts the vector to a Float64Array.
-     * @returns The vector as a Float64Array.
+     * Creates a new GroundStation at a different position.
+     * The original instance remains unchanged.
+     * @param lat - New latitude in degrees
+     * @param lon - New longitude in degrees
+     * @param alt - Optional new altitude in kilometers (defaults to current altitude)
+     * @returns A new GroundStation at the specified position
      */
-    toArray(): Float64Array;
+    moveTo(lat: Degrees, lon: Degrees, alt?: Kilometers): GroundStation;
     /**
-     * Calculates the magnitude of the vector.
-     * @returns The magnitude of the vector.
+     * Returns true since GroundStation is always a ground object.
      */
-    magnitude(): number;
+    isGroundObject(): boolean;
     /**
-     * Adds the elements of another vector to this vector and returns a new
-     * vector.
-     * @param v - The vector to add.
-     * @returns A new vector containing the sum of the elements.
+     * Returns type-specific serialization data.
      */
-    add(v: Vector): Vector;
-    /**
-     * Subtracts a vector from the current vector.
-     * @param v The vector to subtract.
-     * @returns A new vector representing the result of the subtraction.
-     */
-    subtract(v: Vector): Vector;
-    /**
-     * Scales the vector by a given factor.
-     * @param n The scaling factor.
-     * @returns A new Vector object representing the scaled vector.
-     */
-    scale(n: number): Vector;
-    /**
-     * Negates the vector by scaling it by -1.
-     * @returns A new Vector object representing the negated vector.
-     */
-    negate(): Vector;
-    /**
-     * Return the Euclidean distance between this and another Vector.
-     * @param v The vector to calculate the distance to.
-     * @returns The distance between the two vectors.
-     */
-    distance(v: Vector): number;
-    /**
-     * Normalizes the vector, making it a unit vector with the same direction but
-     * a magnitude of 1. If the vector has a magnitude of 0, it returns a zero
-     * vector of the same length.
-     * @returns The normalized vector.
-     */
-    normalize(): Vector;
-    /**
-     * Calculates the dot product of this vector and another vector.
-     * @param v - The vector to calculate the dot product with.
-     * @returns The dot product of the two vectors.
-     */
-    dot(v: Vector): number;
-    /**
-     * Calculates the outer product of this vector with another vector.
-     * @param v The vector to calculate the outer product with.
-     * @returns A matrix representing the outer product of the two vectors.
-     */
-    outer(v: Vector): Matrix;
-    /**
-     * Calculates the cross product of this vector and the given vector.
-     * @param v - The vector to calculate the cross product with.
-     * @returns The resulting vector.
-     */
-    cross(v: Vector): Vector;
-    /**
-     * Calculate the skew-symmetric matrix for this [Vector].
-     * @returns The skew-symmetric matrix.
-     * @throws [Error] if the vector is not of length 3.
-     */
-    skewSymmetric(): Matrix;
-    /**
-     * Rotates the vector around the X-axis by the specified angle.
-     * @param theta The angle in radians.
-     * @returns The rotated vector.
-     */
-    rotX(theta: Radians): Vector;
+    protected serializeSpecific(): Record<string, unknown>;
+    toString(): string;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * This Geodetic class represents a geodetic coordinate in three-dimensional
+ * space, consisting of latitude, longitude, and altitude. It provides various
+ * methods to perform calculations and operations related to geodetic
+ * coordinates.
+ *
+ * This is a class for geodetic coordinates. This is related to the GroundObject
+ * class, which is used to represent an object on the surface of the Earth.
+ */
+declare class Geodetic {
+    readonly lat: Radians;
+    readonly lon: Radians;
+    readonly alt: Kilometers;
+    constructor(latitude: Radians, longitude: Radians, altitude: Kilometers);
     /**
-     * Rotates the vector around the Y-axis by the specified angle.
-     * @param theta The angle of rotation in radians.
-     * @returns A new Vector representing the rotated vector.
+     * Creates a Geodetic object from latitude, longitude, and altitude values in
+     * degrees.
+     * @param latitude The latitude value in degrees.
+     * @param longitude The longitude value in degrees.
+     * @param altitude The altitude value in kilometers.
+     * @returns A Geodetic object representing the specified latitude, longitude,
+     * and altitude.
      */
-    rotY(theta: Radians): Vector;
+    static fromDegrees(latitude: Degrees, longitude: Degrees, altitude: Kilometers): Geodetic;
     /**
-     * Rotates the vector around the Z-axis by the specified angle.
-     * @param theta The angle of rotation in radians.
-     * @returns A new Vector representing the rotated vector.
+     * Returns a string representation of the Geodetic object.
+     * @returns A string containing the latitude, longitude, and altitude of the Geodetic object.
      */
-    rotZ(theta: Radians): Vector;
+    toString(): string;
     /**
-     * Calculates the angle between this vector and another vector.
-     * @param v The other vector.
-     * @returns The angle between the two vectors in radians.
+     * Gets the latitude in degrees.
+     * @returns The latitude in degrees.
      */
-    angle(v: Vector): Radians;
+    get latDeg(): number;
     /**
-     * Calculates the angle between this vector and another vector in degrees.
-     * @param v The other vector.
-     * @returns The angle between the two vectors in degrees.
+     * Gets the longitude in degrees.
+     * @returns The longitude in degrees.
      */
-    angleDegrees(v: Vector): Degrees;
+    get lonDeg(): number;
     /**
-     * Determines if there is line of sight between this vector and another vector
-     * within a given radius.
-     * @param v - The vector to check line of sight with.
-     * @param radius - The radius within which line of sight is considered.
-     * @returns True if there is line of sight, false otherwise.
+     * Converts the geodetic coordinates to a ground station.
+     * @returns The ground station object.
      */
-    sight(v: Vector, radius: number): boolean;
+    toGroundStation(): GroundStation;
     /**
-     * Returns the bisect vector between this vector and the given vector. The
-     * bisect vector is calculated by scaling this vector's magnitude by the
-     * magnitude of the given vector, adding the result to the product of scaling
-     * the given vector's magnitude by this vector's magnitude, and then
-     * normalizing the resulting vector.
-     * @param v - The vector to calculate the bisect with.
-     * @returns The bisect vector.
+     * Converts the geodetic coordinates to the International Terrestrial
+     * Reference Frame (ITRF) coordinates.
+     * @param epoch The epoch in UTC.
+     * @returns The ITRF coordinates.
      */
-    bisect(v: Vector): Vector;
+    toITRF(epoch: EpochUTC): ITRF;
     /**
-     * Joins the current vector with another vector.
-     * @param v The vector to join with.
-     * @returns A new vector that contains the elements of both vectors.
+     * Calculates the angle between two geodetic coordinates.
+     * @param g The geodetic coordinate to calculate the angle to.
+     * @param method The method to use for calculating the angular distance (optional, default is Haversine).
+     * @returns The angle between the two geodetic coordinates in radians.
      */
-    join(v: Vector): Vector;
+    angle(g: Geodetic, method?: AngularDistanceMethod): Radians;
     /**
-     * Returns a new Vector containing a portion of the elements from the
-     * specified start index to the specified end index
-     * @param start The start index of the slice (inclusive).
-     * @param end The end index of the slice (exclusive).
-     * @returns A new Vector containing the sliced elements.
+     * Calculates the angle in degrees between two Geodetic coordinates.
+     * @param g The Geodetic coordinate to calculate the angle with.
+     * @param method The method to use for calculating the angular distance (optional, default is Haversine).
+     * @returns The angle in degrees.
      */
-    slice(start: number, end: number): Vector;
+    angleDeg(g: Geodetic, method?: AngularDistanceMethod): Degrees;
     /**
-     * Returns a new Matrix object representing the row vector.
-     * @returns The row vector as a Matrix object.
+     * Calculates the distance between two geodetic coordinates.
+     * @param g The geodetic coordinates to calculate the distance to.
+     * @param method The method to use for calculating the angular distance. Default is Haversine.
+     * @returns The distance between the two geodetic coordinates in kilometers.
      */
-    row(): Matrix;
+    distance(g: Geodetic, method?: AngularDistanceMethod): Kilometers;
     /**
-     * Returns a new Matrix object representing the column vector of this Vector.
-     * @returns The column vector as a Matrix object.
+     * Calculates the field of view based on the altitude of the Geodetic object.
+     * @returns The field of view in radians.
      */
-    column(): Matrix;
+    fieldOfView(): Radians;
     /**
-     * Converts the elements at the specified index to a Vector3D object.
-     * @param index - The index of the elements to convert.
-     * @returns A new Vector3D object containing the converted elements.
+     * Determines if the current geodetic coordinate can see another geodetic coordinate.
+     * @param g The geodetic coordinate to check for visibility.
+     * @param method The method to use for calculating the angular distance (optional, default is Haversine).
+     * @returns A boolean indicating if the current coordinate can see the other coordinate.
      */
-    toVector3D(index: number): Vector3D;
+    isInView(g: Geodetic, method?: AngularDistanceMethod): boolean;
 }
 
 /**
@@ -2501,151 +2675,419 @@ declare class Vector<T extends number = number> {
  */
 
 /**
- * A matrix is a rectangular array of numbers or other mathematical objects for
- * which operations such as addition and multiplication are defined.
+ * A class containing static methods for formatting TLEs (Two-Line Elements).
  */
-declare class Matrix {
-    elements: number[][];
-    readonly rows: number;
-    readonly columns: number;
-    constructor(elements: number[][]);
+declare abstract class FormatTle {
+    private constructor();
     /**
-     * Creates a matrix with all elements set to zero.
-     * @param rows - The number of rows in the matrix.
-     * @param columns - The number of columns in the matrix.
-     * @returns A matrix with all elements set to zero.
+     * Creates a TLE (Two-Line Element) string based on the provided TleParams.
+     * @param tleParams - The parameters used to generate the TLE.
+     * @returns An object containing the TLE strings tle1 and tle2.
      */
-    static allZeros(rows: number, columns: number): Matrix;
+    static createTle(tleParams: TleParams): {
+        tle1: TleLine1;
+        tle2: TleLine2;
+    };
     /**
-     * Creates a new Matrix with the specified number of rows and columns, filled
-     * with the specified value.
-     * @param rows The number of rows in the matrix.
-     * @param columns The number of columns in the matrix.
-     * @param value The value to fill the matrix with. Default is 0.0.
-     * @returns A new Matrix filled with the specified value.
+     * Converts the argument of perigee to a stringified number.
+     * @param argPe - The argument of perigee to be converted. Can be either a number or a string.
+     * @returns The argument of perigee as a stringified number.
+     * @throws Error if the length of the argument of perigee is not 8.
      */
-    static fill(rows: number, columns: number, value?: number): Matrix;
+    static argumentOfPerigee(argPe: number | string): StringifiedNumber;
     /**
-     * Creates a rotation matrix around the X-axis.
-     * @param theta - The angle of rotation in radians.
-     * @returns The rotation matrix.
+     * Returns the eccentricity value formatted for TLE.
+     * @param ecen - The eccentricity value (string or number).
+     * @returns The eccentricity value formatted as 7 digits without leading "0.".
+     * @throws Error if the length of the eccentricity string is not 7.
      */
-    static rotX(theta: Radians): Matrix;
+    static eccentricity(ecen: string | number): string;
     /**
-     * Creates a rotation matrix around the y-axis.
-     * @param theta - The angle of rotation in radians.
-     * @returns The rotation matrix.
+     * Converts the inclination value to a string representation.
+     * @param inc - The inclination value to be converted.
+     * @returns The string representation of the inclination value.
+     * @throws Error if the length of the converted value is not 8.
      */
-    static rotY(theta: Radians): Matrix;
+    static inclination(inc: number | string): StringifiedNumber;
     /**
-     * Creates a rotation matrix around the Z-axis.
-     * @param theta The angle of rotation in radians.
-     * @returns The rotation matrix.
-     */
-    static rotZ(theta: Radians): Matrix;
-    /**
-     * Creates a zero matrix with the specified number of rows and columns.
-     * @param rows The number of rows in the matrix.
-     * @param columns The number of columns in the matrix.
-     * @returns A new Matrix object representing the zero matrix.
-     */
-    static zero(rows: number, columns: number): Matrix;
-    /**
-     * Creates an identity matrix of the specified dimension.
-     * @param dimension The dimension of the identity matrix.
-     * @returns The identity matrix.
-     */
-    static identity(dimension: number): Matrix;
-    /**
-     * Creates a diagonal matrix with the given diagonal elements.
-     * @param d - An array of diagonal elements.
-     * @returns A new Matrix object representing the diagonal matrix.
-     */
-    static diagonal(d: number[]): Matrix;
-    /**
-     * Adds the elements of another matrix to this matrix and returns the result.
-     * @param m - The matrix to be added.
-     * @returns The resulting matrix after addition.
-     */
-    add(m: Matrix): Matrix;
-    /**
-     * Subtracts the elements of another matrix from this matrix.
-     * @param m - The matrix to subtract.
-     * @returns A new matrix containing the result of the subtraction.
+     * Converts the mean anomaly to a string representation with 8 digits, padded with leading zeros.
+     * @param meana - The mean anomaly to be converted. Can be either a number or a string.
+     * @returns The mean anomaly as a string with 8 digits, padded with leading zeros.
+     * @throws Error if the length of the mean anomaly is not 8.
      */
-    subtract(m: Matrix): Matrix;
+    static meanAnomaly(meana: number | string): StringifiedNumber;
     /**
-     * Scales the matrix by multiplying each element by a scalar value.
-     * @param n - The scalar value to multiply each element by.
-     * @returns A new Matrix object representing the scaled matrix.
+     * Converts the mean motion value to a string representation with 8 decimal
+     * places. If the input is a number, it is converted to a string. If the input
+     * is already a string, it is parsed as a float and then converted to a string
+     * with 8 decimal places. The resulting string is padded with leading zeros to
+     * ensure a length of 11 characters. Throws an error if the resulting string
+     * does not have a length of 11 characters.
+     * @param meanmo - The mean motion value to be converted.
+     * @returns The string representation of the mean motion value with 8 decimal
+     * places and padded with leading zeros.
+     * @throws Error if the resulting string does not have a length of 11
+     * characters.
      */
-    scale(n: number): Matrix;
+    static meanMotion(meanmo: number | string): StringifiedNumber;
     /**
-     * Negates the matrix by scaling it by -1.
-     * @returns The negated matrix.
+     * Converts the right ascension value to a stringified number.
+     * @param rasc - The right ascension value to convert.
+     * @returns The stringified number representation of the right ascension.
+     * @throws Error if the length of the converted right ascension is not 8.
      */
-    negate(): Matrix;
+    static rightAscension(rasc: number | string): StringifiedNumber;
     /**
-     * Multiplies this matrix with another matrix.
-     * @param m The matrix to multiply with.
-     * @returns The resulting matrix.
+     * Sets a character at a specific index in a string. If the index is out of range, the original string is returned.
+     * @param str - The input string.
+     * @param index - The index at which to set the character.
+     * @param chr - The character to set at the specified index.
+     * @returns The modified string with the character set at the specified index.
      */
-    multiply(m: Matrix): Matrix;
+    static setCharAt(str: string, index: number, chr: string): string;
     /**
-     * Computes the outer product of this matrix with another matrix.
-     * @param m - The matrix to compute the outer product with.
-     * @returns The resulting matrix.
+     * Format mean motion dot (first derivative / 2) for TLE line 1.
+     * Format: sign + ".NNNNNNNN" = 10 chars total.
+     * @param value - Mean motion dot value (rev/day^2)
+     * @returns Formatted 10-character string
      */
-    outerProduct(m: Matrix): Matrix;
+    static formatMeanMotionDot(value: number): string;
     /**
-     * Multiplies the matrix by a vector.
-     * @param v The vector to multiply by.
-     * @returns A new vector representing the result of the multiplication.
+     * Format a value in TLE exponential notation for BSTAR or mean motion ddot.
+     * Format: "sNNNNN±N" (8 chars) where mantissa has implied leading decimal point.
+     * Example: 0.00017507 → " 17507-3" (i.e., .17507 × 10^-3)
+     * @param value - The value to format
+     * @returns Formatted 8-character string
      */
-    multiplyVector(v: Vector): Vector;
+    static formatTleExponential(value: number): string;
     /**
-     * Multiplies a 3D vector by the matrix.
-     * @template T - The type of the vector elements.
-     * @param v - The 3D vector to multiply.
-     * @returns The resulting 3D vector after multiplication.
+     * Compute TLE line checksum (modulo 10 sum of digits, '-' counts as 1).
+     * @param line - TLE line (first 68 characters are summed)
+     * @returns Checksum digit (0-9)
      */
-    multiplyVector3D<T extends number>(v: Vector3D<T>): Vector3D<T>;
+    static tleChecksum(line: string): number;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare abstract class Force {
     /**
-     * Returns a new Matrix object where each element is the reciprocal of the
-     * corresponding element in the current matrix. If an element in the current
-     * matrix is zero, the corresponding element in the output matrix will also be
-     * zero.
-     * @returns A new Matrix object representing the reciprocal of the current
-     * matrix.
+     * Calculate the acceleration due to the perturbing force on a given
+     * state vector.
+     * @param state The state vector.
+     * @throws If the force cannot be calculated.
      */
-    reciprocal(): Matrix;
+    abstract acceleration(state: J2000): Vector3D;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare class Thrust implements Force {
+    center: EpochUTC;
+    radial: MetersPerSecond;
+    intrack: MetersPerSecond;
+    crosstrack: MetersPerSecond;
+    durationRate: SecondsPerMeterPerSecond;
+    constructor(center: EpochUTC, radial: MetersPerSecond, intrack: MetersPerSecond, crosstrack: MetersPerSecond, durationRate?: SecondsPerMeterPerSecond);
+    deltaV: Vector3D<KilometersPerSecond>;
+    get magnitude(): MetersPerSecond;
+    get duration(): Seconds;
+    get start(): EpochUTC;
+    get stop(): EpochUTC;
+    acceleration(state: J2000): Vector3D;
+    apply(state: J2000): J2000;
+    get isImpulsive(): boolean;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare class EpochWindow {
+    start: EpochUTC;
+    end: EpochUTC;
+    constructor(start: EpochUTC, end: EpochUTC);
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare abstract class Interpolator {
+    abstract window(): EpochWindow;
+    inWindow(epoch: EpochUTC): boolean;
+    overlap(interpolator: Interpolator): EpochWindow | null;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare abstract class StateInterpolator extends Interpolator {
     /**
-     * Transposes the matrix by swapping rows with columns.
-     * @returns A new Matrix object representing the transposed matrix.
+     * Interpolates the state at the given epoch.
+     * @param epoch The epoch in UTC format.
+     * @throws If the interpolator has not been initialized.
      */
-    transpose(): Matrix;
+    abstract interpolate(epoch: EpochUTC): J2000 | null;
+    get sizeBytes(): number;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare class ForceModel {
+    private centralGravity_?;
+    private thirdBodyGravity_?;
+    private solarRadiationPressure_?;
+    private atmosphericDrag_?;
+    private maneuverThrust_;
+    setGravity(mu?: number): this;
+    setEarthGravity(degree: number, order: number): void;
+    setThirdBodyGravity({ moon, sun }: {
+        moon?: boolean | undefined;
+        sun?: boolean | undefined;
+    }): void;
+    setSolarRadiationPressure(mass: number, area: number, coeff?: number): void;
     /**
-     * Performs the Cholesky decomposition on the matrix.
-     * @returns A new Matrix object representing the Cholesky decomposition of the
-     * original matrix.
+     * Sets the atmospheric drag for the force model.
+     * @deprecated This is still a work in progress!
+     * @param mass - The mass of the object.
+     * @param area - The cross-sectional area of the object.
+     * @param coeff - The drag coefficient. Default value is 2.2.
+     * @param cosine - The cosine of the angle between the object's velocity vector and the drag force vector.
      */
-    cholesky(): Matrix;
+    setAtmosphericDrag(mass: number, area: number, coeff?: number, cosine?: number): void;
+    loadManeuver(maneuver: Thrust): void;
+    clearManeuver(): void;
+    acceleration(state: J2000): Vector3D;
+    derivative(state: J2000): Vector;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare class Waypoint {
+    epoch: EpochUTC;
+    relativePosition: Vector3D<Kilometers>;
+    constructor(epoch: EpochUTC, relativePosition: Vector3D<Kilometers>);
     /**
-     * Swaps two rows in the matrix.
-     * @param i - The index of the first row.
-     * @param j - The index of the second row.
+     * Return the perturbed error in a [maneuver] when compared against the
+     * target [waypoint] given an initial [state], [forceModel],
+     * [target] interpolator, and speculative relative maneuver
+     * [components] _(m/s)_.
+     * @param waypoint The waypoint to target.
+     * @param maneuver The maneuver to perturb.
+     * @param state The initial state of the interceptor.
+     * @param forceModel The force model to use for propagation.
+     * @param target The target interpolator.
+     * @param components The speculative maneuver components.
+     * @returns The perturbed error in the maneuver.
      */
-    private _swapRows;
+    static _error(waypoint: Waypoint, maneuver: Thrust, state: J2000, forceModel: ForceModel, target: StateInterpolator, components: Float64Array): number;
     /**
-     * Converts the matrix to reduced row echelon form using the Gaussian
-     * elimination method. This method modifies the matrix in-place.
+     * Generate a score function for refining perturbed [waypoint] maneuvers.
+     *
+     * The score function takes an array of speculative radial, intrack, and
+     * crosstrack components _(m/s)_ and returns the propagated error from the
+     * desired waypoint target.
+     * @param waypoint The waypoint to target.
+     * @param maneuver The maneuver to perturb.
+     * @param state The initial state of the interceptor.
+     * @param forceModel The force model to use for propagation.
+     * @param target The target interpolator.
+     * @returns A score function for refining maneuvers.
      */
-    private toReducedRowEchelonForm_;
+    static _refineManeuverScore(waypoint: Waypoint, maneuver: Thrust, state: J2000, forceModel: ForceModel, target: StateInterpolator): (components: Float64Array) => number;
     /**
-     * Calculates the inverse of the matrix.
-     * @returns The inverse of the matrix.
+     * Convert an array of [waypoints] into a maneuver sequence given an
+     * [interceptor] state, [pivot] epoch for the first burn to arrive at the
+     * first waypoint, and [target] ephemeris interpolator.
+     *
+     * Optional arguments are as follows:
+     *  - `preManeuvers`: maneuvers to execute before the pivot burn
+     * - `postManeuvers`: maneuvers to execute after the last pivot burn
+     * - `durationRate`: thruster duration rate _(s/m/s)_
+     * - `forceModel`: interceptor force model, defaults to two-body
+     * - `refine`: refine maneuvers to account for perturbations if `true`
+     * - `maxIter`: maximum refinement iterations per maneuver
+     * - `printIter`: print debug information on each refinement iteration
+     * @param interceptor The interceptor state.
+     * @param pivot The epoch of the first burn.
+     * @param waypoints The waypoints to target.
+     * @param target The target interpolator.
+     * @param preManeuvers The maneuvers to execute before the pivot burn.
+     * @param postManeuvers The maneuvers to execute after the last pivot burn.
+     * @param root0 The optional arguments.
+     * @param root0.durationRate The thruster duration rate.
+     * @param root0.forceModel The interceptor force model.
+     * @param root0.refine Whether to refine maneuvers to account for perturbations.
+     * @param root0.maxIter The maximum refinement iterations per maneuver.
+     * @param root0.printIter Whether to print debug information on each refinement iteration.
+     * @returns An array of maneuvers.
      */
-    inverse(): Matrix;
+    static toManeuvers(interceptor: J2000, pivot: EpochUTC, waypoints: Waypoint[], target: StateInterpolator, preManeuvers: Thrust[] | null, postManeuvers: Thrust[] | null, { durationRate, forceModel, refine, maxIter, printIter, }?: {
+        durationRate?: number;
+        forceModel?: ForceModel;
+        refine?: boolean;
+        maxIter?: number;
+        printIter?: boolean;
+    }): Thrust[];
+    static _refineManeuvers(waypoints: Waypoint[], maneuvers: Thrust[], interceptor: J2000, forceModel: ForceModel, target: StateInterpolator, { maxIter, printIter, }?: {
+        maxIter?: number;
+        printIter?: boolean;
+    }): Thrust[];
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare class Hill {
+    epoch: EpochUTC;
+    position: Vector3D<Kilometers>;
+    velocity: Vector3D<KilometersPerSecond>;
+    private semimajorAxis_;
+    private meanMotion_;
+    constructor(epoch: EpochUTC, position: Vector3D<Kilometers>, velocity: Vector3D<KilometersPerSecond>, semimajorAxis: Kilometers);
+    static fromState(origin: J2000, radialPosition: Kilometers, intrackPosition: Kilometers, nodeVelocity: KilometersPerSecond, nodeOffsetTime: Seconds): Hill;
+    static fromNmc(origin: J2000, majorAxisRange: Kilometers, nodeVelocity: KilometersPerSecond, nodeOffsetTime: Seconds, translation?: number): Hill;
+    static fromPerch(origin: J2000, perchRange: Kilometers, nodeVelocity: KilometersPerSecond, nodeOffsetTime: Seconds): Hill;
+    get semimajorAxis(): Kilometers;
+    set semimajorAxis(sma: Kilometers);
+    get meanMotion(): RadiansPerSecond;
+    toJ2000Matrix(origin: J2000, transform: Matrix): J2000;
+    toJ2000(origin: J2000): J2000;
+    static transitionMatrix(t: number, meanMotion: number): Matrix;
+    transition(t: Seconds): Hill;
+    transitionWithMatrix(stm: Matrix, t: Seconds): Hill;
+    propagate(newEpoch: EpochUTC): Hill;
+    propagateWithMatrix(stm: Matrix, newEpoch: EpochUTC): Hill;
+    maneuver(maneuver: Thrust): Hill;
+    ephemeris(start: EpochUTC, stop: EpochUTC, step?: Seconds): Hill[];
+    get period(): Seconds;
+    nextRadialTangent(): Hill;
+    solveManeuver(waypoint: Waypoint, ignoreCrosstrack?: boolean): Thrust;
+    maneuverSequence(pivot: EpochUTC, waypoints: Waypoint[], preManeuvers?: Thrust[], postManeuvers?: Thrust[]): Thrust[];
+    maneuverOrigin(maneuver: Thrust): Hill;
+    get name(): string;
+    toString(): string;
 }
 
 /**
@@ -3002,7 +3444,8 @@ declare class Tle {
     satnum: number;
     private readonly satrec_;
     /**
-     * Mapping of alphabets to their corresponding numeric values.
+     * Mapping of alpha-5 leading letters to their numeric values. Sourced from the
+     * leaf `alpha5` module so TLE format helpers can share it without importing Tle.
      */
     private static readonly alpha5_;
     /** The argument of perigee field. */
@@ -3435,140 +3878,38 @@ declare class Tle {
  * You should have received a copy of the GNU Affero General Public License along with
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
-
-/**
- * Options for creating a propagator from a Satellite via `createPropagator()`.
- */
-interface NumericalPropagatorOptions {
-    /**
-     * The propagator type to create. Defaults to PropagatorType.RK89.
-     */
-    type?: PropagatorType;
-    /**
-     * The force model for numerical propagators (RK4, DP54, RK89).
-     * If not provided, defaults to point-mass gravity.
-     * Ignored for SGP4 and KEPLER types.
-     */
-    forceModel?: ForceModel;
-    /**
-     * Tolerance for adaptive propagators (DP54, RK89).
-     * Smaller values = more accurate but slower.
-     * Defaults to 1e-9.
-     * Ignored for SGP4, KEPLER, and RK4.
-     */
-    tolerance?: number;
-    /**
-     * Fixed step size in seconds for RK4 propagator.
-     * Defaults to 15.0 seconds.
-     * Ignored for other propagator types.
-     */
-    stepSize?: number;
-}
-
-interface OptionsParams {
-    notes: string;
-}
-
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-/**
- * Configuration options for history tracking.
- */
-interface HistoryConfig {
-    /** Maximum number of entries to store. Undefined means unlimited. */
-    maxLength?: number;
-    /** Minimum time between samples in milliseconds. */
-    samplingInterval?: number;
-    /** If true, automatically removes oldest entries when maxLength is reached. */
-    autoClean?: boolean;
-}
-/**
- * A single entry in the history.
- */
-interface HistoryEntry<T> {
-    time: Date;
-    data: T;
-}
-/**
- * Generic history tracking class for storing time-stamped data.
- * Used to track object state over time for visualization and analysis.
- */
-declare class History<T> {
-    private entries_;
-    private config_;
-    private lastSampleTime_;
-    constructor(config?: HistoryConfig);
-    /**
-     * Adds a new entry to the history.
-     * Respects sampling interval and max length constraints.
-     * @param time - The timestamp for this entry
-     * @param data - The data to store
-     */
-    add(time: Date, data: T): void;
-    /**
-     * Returns all history entries.
-     */
-    getAll(): HistoryEntry<T>[];
-    /**
-     * Returns entries within a time range (inclusive).
-     * @param start - Start of the time range
-     * @param end - End of the time range
-     */
-    getRange(start: Date, end: Date): HistoryEntry<T>[];
-    /**
-     * Returns the last n entries.
-     * @param n - Number of entries to return
-     */
-    getLast(n: number): HistoryEntry<T>[];
-    /**
-     * Returns the first entry, or undefined if empty.
-     */
-    getFirst(): HistoryEntry<T> | undefined;
-    /**
-     * Returns the most recent entry, or undefined if empty.
-     */
-    getLatest(): HistoryEntry<T> | undefined;
-    /**
-     * Clears all history entries.
-     */
-    clear(): void;
-    /**
-     * Creates a deep copy of this history.
-     * @returns A new History instance with cloned entries
-     */
-    clone(): History<T>;
+
+/**
+ * Options for creating a propagator from a Satellite via `createPropagator()`.
+ */
+interface NumericalPropagatorOptions {
     /**
-     * Returns the number of entries in the history.
+     * The propagator type to create. Defaults to PropagatorType.RK89.
      */
-    get length(): number;
+    type?: PropagatorType;
     /**
-     * Returns the current configuration.
+     * The force model for numerical propagators (RK4, DP54, RK89).
+     * If not provided, defaults to point-mass gravity.
+     * Ignored for SGP4 and KEPLER types.
      */
-    get config(): HistoryConfig;
+    forceModel?: ForceModel;
     /**
-     * Returns true if the history is empty.
+     * Tolerance for adaptive propagators (DP54, RK89).
+     * Smaller values = more accurate but slower.
+     * Defaults to 1e-9.
+     * Ignored for SGP4, KEPLER, and RK4.
      */
-    get isEmpty(): boolean;
+    tolerance?: number;
     /**
-     * Returns the time span covered by the history in milliseconds.
-     * Returns 0 if there are fewer than 2 entries.
+     * Fixed step size in seconds for RK4 propagator.
+     * Defaults to 15.0 seconds.
+     * Ignored for other propagator types.
      */
-    get timeSpan(): number;
-    toString(): string;
+    stepSize?: number;
+}
+
+interface OptionsParams {
+    notes: string;
 }
 
 /**
@@ -3917,241 +4258,44 @@ declare abstract class Propagator {
  */
 
 declare abstract class RungeKuttaAdaptive extends Propagator {
-    private readonly initState_;
-    private forceModel_;
-    private readonly tolerance_;
-    /**
-     * Create a new [RungeKuttaAdaptive] object from an initial state vector
-     * along with an optional [ForceModel] and [tolerance].
-     * @param initState_ Initial state vector.
-     * @param forceModel_ Numerical integration force model.
-     * @param tolerance_ Minimum allowable local error tolerance.
-     */
-    constructor(initState_: J2000, forceModel_?: ForceModel, tolerance_?: number);
-    private _cacheState;
-    private readonly _checkpoints;
-    private _stepSize;
-    private static readonly _minTolerance;
-    protected abstract get a(): Float64Array;
-    protected abstract get b(): Float64Array[];
-    protected abstract get ch(): Float64Array;
-    protected abstract get c(): Float64Array;
-    protected abstract get order(): number;
-    get state(): J2000;
-    reset(): void;
-    setForceModel(forceModel: ForceModel): void;
-    private kfn_;
-    private integrate_;
-    propagate(epoch: EpochUTC): J2000;
-    maneuver(maneuver: Thrust, interval?: Seconds): J2000[];
-    ephemerisManeuver(start: EpochUTC, finish: EpochUTC, maneuvers: Thrust[], interval?: Seconds): VerletBlendInterpolator;
-    checkpoint(): number;
-    clearCheckpoints(): void;
-    restore(index: number): void;
-}
-
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-declare class RungeKutta89Propagator extends RungeKuttaAdaptive {
-    private readonly a_;
-    private readonly b_;
-    private readonly ch_;
-    private readonly c_;
-    get a(): Float64Array;
-    get b(): Float64Array[];
-    get ch(): Float64Array;
-    get c(): Float64Array;
-    get order(): number;
-}
-
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * Sgp4Propagator is a propagator that uses the SGP4 model to propagate the state of an object.
- * This class is useful for propagating multiple states with the same TLE, since it caches the
- * state of the TLE at different epochs.
- */
-declare class Sgp4Propagator extends Propagator {
-    private readonly tle_;
-    constructor(tle_: Tle);
-    private cacheState_;
-    private checkpoints_;
-    /**
-     * Gets the state of the propagator in the J2000 coordinate system.
-     * @returns The J2000 state of the propagator.
-     */
-    get state(): J2000;
-    /**
-     * Calculates the ephemeris maneuver using the SGP4 propagator.
-     * @param start The start epoch in UTC.
-     * @param finish The finish epoch in UTC.
-     * @param maneuvers The array of thrust maneuvers.
-     * @param interval The time interval in seconds.
-     */
-    ephemerisManeuver(_start: EpochUTC, _finish: EpochUTC, _maneuvers: Thrust[], _interval?: number): VerletBlendInterpolator;
-    /**
-     * Performs a maneuver with the given thrust.
-     * @param maneuver - The thrust maneuver to perform.
-     * @param interval - The time interval for the maneuver (default: 60.0 seconds).
-     * @throws Error if maneuvers cannot be modeled with SGP4.
-     */
-    maneuver(_maneuver: Thrust, _interval?: number): J2000[];
-    /**
-     * Propagates the state of the Sgp4Propagator to a specified epoch in J2000 coordinates.
-     * @param epoch - The epoch in UTC format.
-     * @returns The propagated state in J2000 coordinates.
-     */
-    propagate(epoch: EpochUTC): J2000;
-    /**
-     * Resets the state of the Sgp4Propagator by updating the cache state
-     * to the current J2000 state of the TLE.
-     */
-    reset(): void;
-    /**
-     * Saves the current state of the propagator and returns the index of the checkpoint.
-     * @returns The index of the checkpoint.
-     */
-    checkpoint(): number;
-    /**
-     * Clears all the checkpoints in the propagator.
-     */
-    clearCheckpoints(): void;
-    /**
-     * Restores the state of the propagator to a previously saved checkpoint.
-     * @param index - The index of the checkpoint to restore.
-     */
-    restore(index: number): void;
-}
-
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-interface BaseObjectParams {
-    id?: number;
-    name?: string;
-    type?: SpaceObjectType;
-    active?: boolean;
-    metadata?: Record<string, unknown>;
-}
-
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * State data that can be recorded in history.
- */
-interface HistoricalState {
-    position: TemeVec3;
-    velocity: TemeVec3<KilometersPerSecond>;
-}
-/**
- * Serialized representation of a BaseObject.
- * Used for persistence and data transfer.
- */
-interface SerializedObject {
-    /** The class name of the object */
-    type: string;
-    /** Unique identifier */
-    id: number;
-    /** Human-readable name */
-    name: string;
-    /** Additional type-specific data */
-    [key: string]: unknown;
-}
-/**
- * Placeholder interface for sensors (will be defined in Phase 2).
- * This allows SpaceObject and GroundObject to reference sensors
- * without creating circular dependencies.
- */
-interface SensorInterface {
-    id: number;
-    name: string;
-}
-/**
- * Placeholder interface for communication devices (will be defined in Phase 3).
- * This allows SpaceObject and GroundObject to reference comm devices
- * without creating circular dependencies.
- */
-interface CommunicationDeviceInterface {
-    id: number;
-    name: string;
+    private readonly initState_;
+    private forceModel_;
+    private readonly tolerance_;
+    /**
+     * Create a new [RungeKuttaAdaptive] object from an initial state vector
+     * along with an optional [ForceModel] and [tolerance].
+     * @param initState_ Initial state vector.
+     * @param forceModel_ Numerical integration force model.
+     * @param tolerance_ Minimum allowable local error tolerance.
+     */
+    constructor(initState_: J2000, forceModel_?: ForceModel, tolerance_?: number);
+    private _cacheState;
+    private readonly _checkpoints;
+    private _stepSize;
+    private static readonly _minTolerance;
+    protected abstract get a(): Float64Array;
+    protected abstract get b(): Float64Array[];
+    protected abstract get ch(): Float64Array;
+    protected abstract get c(): Float64Array;
+    protected abstract get order(): number;
+    get state(): J2000;
+    reset(): void;
+    setForceModel(forceModel: ForceModel): void;
+    private kfn_;
+    private integrate_;
+    propagate(epoch: EpochUTC): J2000;
+    maneuver(maneuver: Thrust, interval?: Seconds): J2000[];
+    ephemerisManeuver(start: EpochUTC, finish: EpochUTC, maneuvers: Thrust[], interval?: Seconds): VerletBlendInterpolator;
+    checkpoint(): number;
+    clearCheckpoints(): void;
+    restore(index: number): void;
 }
 
 /**
  * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
  * @license AGPL-3.0-or-later
  * @copyright (c) 2025-2026 Kruczek Labs LLC
  *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
  * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Affero General Public License as published by the Free Software
  * Foundation, either version 3 of the License, or (at your option) any later version.
@@ -4164,110 +4308,23 @@ interface CommunicationDeviceInterface {
  * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/**
- * Abstract base class for all objects in the ootk system.
- * Provides common functionality for identification, type checking,
- * history tracking, and serialization.
- */
-declare abstract class BaseObject {
-    /** Unique identifier for the object */
-    id: number;
-    /** Human-readable name */
-    name: string;
-    /** Type classification of the object */
-    type: SpaceObjectType;
-    /** Whether the object is currently active */
-    active: boolean;
-    /** Additional metadata for the object */
-    metadata?: Record<string, unknown>;
-    /** History tracking (null until enabled) */
-    private history_;
-    constructor(info: BaseObjectParams);
-    /**
-     * Enables history tracking for this object.
-     * @param config - Optional configuration for history behavior
-     */
-    enableHistory(config?: HistoryConfig): void;
-    /**
-     * Disables history tracking and clears existing history.
-     */
-    disableHistory(): void;
-    /**
-     * Returns the history object if enabled, null otherwise.
-     */
-    get history(): History<HistoricalState> | null;
-    /**
-     * Returns true if history tracking is enabled.
-     */
-    get isHistoryEnabled(): boolean;
-    /**
-     * Records a state to history if history tracking is enabled.
-     * @param time - The timestamp for this state
-     * @param state - The state to record
-     */
-    protected recordToHistory(time: Date, state: HistoricalState): void;
-    /**
-     * Serializes the object to a plain object for persistence.
-     */
-    serialize(): SerializedObject;
-    /**
-     * Returns type-specific serialization data.
-     * Subclasses must implement this to add their specific properties.
-     */
-    protected abstract serializeSpecific(): Record<string, unknown>;
-    /**
-     * Checks if the object is a satellite.
-     * @returns True if the object is a satellite, false otherwise.
-     */
-    isSatellite(): boolean;
-    /**
-     * Checks if the object is a ground object.
-     * @returns True if the object is a ground object, false otherwise.
-     */
-    isGroundObject(): boolean;
-    /**
-     * Returns whether the object is a sensor.
-     * @returns True if the object is a sensor, false otherwise.
-     */
-    isSensor(): boolean;
-    /**
-     * Checks if the object is a marker.
-     * @returns True if the object is a marker, false otherwise.
-     */
-    isMarker(): boolean;
-    /**
-     * Returns whether the object's position is static.
-     * @returns True if the object is static, false otherwise.
-     */
-    isStatic(): boolean;
-    isPayload(): boolean;
-    isRocketBody(): boolean;
-    isDebris(): boolean;
-    isStar(): boolean;
-    isMissile(): boolean;
-    isNotional(): boolean;
-    getTypeString(): string;
-    /**
-     * Validates a parameter value against a minimum and maximum value.
-     * @param value - The value to be validated.
-     * @param minValue - The minimum allowed value.
-     * @param maxValue - The maximum allowed value.
-     * @param errorMessage - The error message to be thrown if the value is invalid.
-     */
-    validateParameter<T>(value: T, minValue: T | null, maxValue: T | null, errorMessage: string): void;
+declare class RungeKutta89Propagator extends RungeKuttaAdaptive {
+    private readonly a_;
+    private readonly b_;
+    private readonly ch_;
+    private readonly c_;
+    get a(): Float64Array;
+    get b(): Float64Array[];
+    get ch(): Float64Array;
+    get c(): Float64Array;
+    get order(): number;
 }
 
 /**
  * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
  * @license AGPL-3.0-or-later
  * @copyright (c) 2025-2026 Kruczek Labs LLC
  *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
  * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Affero General Public License as published by the Free Software
  * Foundation, either version 3 of the License, or (at your option) any later version.
@@ -4281,100 +4338,60 @@ declare abstract class BaseObject {
  */
 
 /**
- * Parameters for constructing a GroundObject.
- */
-interface GroundObjectParams extends BaseObjectParams {
-    lat: Degrees;
-    lon: Degrees;
-    alt: Kilometers;
-}
-/**
- * Abstract base class for all objects on Earth's surface.
- * Provides coordinate conversion methods and component attachment capabilities.
+ * Sgp4Propagator is a propagator that uses the SGP4 model to propagate the state of an object.
+ * This class is useful for propagating multiple states with the same TLE, since it caches the
+ * state of the TLE at different epochs.
  */
-declare abstract class GroundObject extends BaseObject {
-    name: string;
-    readonly lat: Degrees;
-    readonly lon: Degrees;
-    readonly alt: Kilometers;
-    /** Sensors attached to this ground object */
-    sensors: SensorInterface[];
-    /** Communication devices attached to this ground object */
-    commDevices: CommunicationDeviceInterface[];
-    constructor(info: GroundObjectParams);
-    /**
-     * Calculates the relative azimuth, elevation, and range between this GroundObject and a Satellite.
-     * @param satellite The Satellite object.
-     * @param date The date for which to calculate the RAE values. Defaults to the current date.
-     * @returns The relative azimuth, elevation, and range values in kilometers and degrees.
-     */
-    rae(satellite: Satellite, date?: Date): RaeVec3<Kilometers, Degrees> | null;
-    /**
-     * Calculates ECEF position at a given time.
-     * @variation optimized version of this.toGeodetic().toITRF().position;
-     * @returns The ECEF position vector of the ground object.
-     */
-    ecef(): EcefVec3<Kilometers>;
-    /**
-     * Calculates the Earth-Centered Inertial (ECI) position vector of the ground object at a given date.
-     * @variation optimized version of this.toGeodetic().toITRF().toJ2000().position;
-     * @param date The date for which to calculate the ECI position vector. Defaults to the current date.
-     * @returns The ECI position vector of the ground object.
-     */
-    eci(date?: Date): TemeVec3<Kilometers>;
-    /**
-     * Returns the latitude, longitude, and altitude of the GroundObject.
-     * @returns The latitude, longitude, and altitude as an LlaVec3 object.
-     */
-    lla(): LlaVec3<Degrees, Kilometers>;
+declare class Sgp4Propagator extends Propagator {
+    private readonly tle_;
+    constructor(tle_: Tle);
+    private cacheState_;
+    private checkpoints_;
     /**
-     * Converts the latitude, longitude, and altitude of the GroundObject to radians and kilometers.
-     * @variation optimized version of this.toGeodetic() without class instantiation for better performance and
-     * serialization.
-     * @returns An object containing the latitude, longitude, and altitude in radians and kilometers.
+     * Gets the state of the propagator in the J2000 coordinate system.
+     * @returns The J2000 state of the propagator.
      */
-    llaRad(): LlaVec3<Radians, Kilometers>;
-    get latRad(): Radians;
-    get lonRad(): Radians;
+    get state(): J2000;
     /**
-     * Converts the ground position to geodetic coordinates.
-     * @returns The geodetic coordinates.
+     * Calculates the ephemeris maneuver using the SGP4 propagator.
+     * @param start The start epoch in UTC.
+     * @param finish The finish epoch in UTC.
+     * @param maneuvers The array of thrust maneuvers.
+     * @param interval The time interval in seconds.
      */
-    toGeodetic(): Geodetic;
+    ephemerisManeuver(_start: EpochUTC, _finish: EpochUTC, _maneuvers: Thrust[], _interval?: number): VerletBlendInterpolator;
     /**
-     * Converts the ground position to J2000 inertial coordinates.
-     * Ground objects have zero velocity in the inertial frame (ignoring Earth rotation).
-     * @param date - The date for the conversion (defaults to now)
-     * @returns J2000 state vector
+     * Performs a maneuver with the given thrust.
+     * @param maneuver - The thrust maneuver to perform.
+     * @param interval - The time interval for the maneuver (default: 60.0 seconds).
+     * @throws Error if maneuvers cannot be modeled with SGP4.
      */
-    toJ2000(date?: Date): J2000;
+    maneuver(_maneuver: Thrust, _interval?: number): J2000[];
     /**
-     * Adds a sensor to this ground object.
-     * @param sensor - The sensor to add
+     * Propagates the state of the Sgp4Propagator to a specified epoch in J2000 coordinates.
+     * @param epoch - The epoch in UTC format.
+     * @returns The propagated state in J2000 coordinates.
      */
-    addSensor(sensor: SensorInterface): void;
+    propagate(epoch: EpochUTC): J2000;
     /**
-     * Removes a sensor from this ground object.
-     * @param sensorId - The ID of the sensor to remove
+     * Resets the state of the Sgp4Propagator by updating the cache state
+     * to the current J2000 state of the TLE.
      */
-    removeSensor(sensorId: number): void;
+    reset(): void;
     /**
-     * Adds a communication device to this ground object.
-     * @param device - The device to add
+     * Saves the current state of the propagator and returns the index of the checkpoint.
+     * @returns The index of the checkpoint.
      */
-    addCommDevice(device: CommunicationDeviceInterface): void;
+    checkpoint(): number;
     /**
-     * Removes a communication device from this ground object.
-     * @param deviceId - The ID of the device to remove
+     * Clears all the checkpoints in the propagator.
      */
-    removeCommDevice(deviceId: number): void;
-    isGroundObject(): boolean;
+    clearCheckpoints(): void;
     /**
-     * Validates the input data for the GroundObject.
-     * @param info - The GroundPositionParams object containing the latitude,
-     * longitude, and altitude.
+     * Restores the state of the propagator to a previously saved checkpoint.
+     * @param index - The index of the checkpoint to restore.
      */
-    private validateGroundObjectInputData_;
+    restore(index: number): void;
 }
 
 /**
@@ -6109,35 +6126,6 @@ interface StarObjectParams extends BaseObjectParams {
     bayer?: string;
 }
 
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-declare class EpochWindow {
-    start: EpochUTC;
-    end: EpochUTC;
-    constructor(start: EpochUTC, end: EpochUTC);
-}
-
 /**
  * @author Theodore Kruczek
  * @description Orbital Object ToolKit (ootk) is a collection of tools for working
@@ -7545,6 +7533,49 @@ declare const MILLISECONDS_PER_SECOND: Milliseconds;
 declare const RADIUS_OF_EARTH = 6371;
 declare const earthGravityParam = 398600.4415;
 
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** Covariance Frame */
+declare enum CovarianceFrame {
+    /** Earth-centered inertial */
+    ECI = "eci",
+    /** Radial-Intrack-Crosstrack */
+    RIC = "ric"
+}
+declare class StateCovariance {
+    matrix: Matrix;
+    frame: CovarianceFrame;
+    /**
+     * Create a new [StateCovariance] object given its covariance [matrix] and
+     * [CovarianceFrame].
+     * @param matrix The covariance matrix.
+     * @param frame The covariance frame.
+     * @returns A new [StateCovariance] object.
+     */
+    constructor(matrix: Matrix, frame: CovarianceFrame);
+    static fromSigmas(sigmas: number[], frame: CovarianceFrame): StateCovariance;
+    /**
+     * Calculates the standard deviations (sigmas) of each element in the covariance matrix.
+     * @returns A vector containing the standard deviations of each element in the covariance matrix.
+     */
+    sigmas(): Vector;
+}
+
 /**
  * Creates a 6x6 state covariance matrix from a TLE
  * @param tleLine1 The first line of the TLE
@@ -8863,65 +8894,6 @@ declare class EphemerisSatellite extends SpaceObject {
     private createInterpolator_;
 }
 
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * Parameters for constructing a GroundStation.
- */
-interface GroundStationParams extends GroundObjectParams {
-}
-/**
- * A concrete ground station that can host sensors and communication devices.
- * Use this class for fixed ground locations like tracking stations, observatories, etc.
- */
-declare class GroundStation extends GroundObject {
-    constructor(info: GroundStationParams);
-    /**
-     * Creates a GroundStation from a Geodetic position.
-     * @param geodetic - The geodetic coordinates
-     * @param name - Optional name for the station
-     * @param id - Optional unique identifier
-     */
-    static fromGeodetic(geodetic: Geodetic, name?: string, id?: number): GroundStation;
-    /**
-     * Creates a deep copy of this ground station.
-     */
-    clone(): GroundStation;
-    /**
-     * Creates a new GroundStation at a different position.
-     * The original instance remains unchanged.
-     * @param lat - New latitude in degrees
-     * @param lon - New longitude in degrees
-     * @param alt - Optional new altitude in kilometers (defaults to current altitude)
-     * @returns A new GroundStation at the specified position
-     */
-    moveTo(lat: Degrees, lon: Degrees, alt?: Kilometers): GroundStation;
-    /**
-     * Returns true since GroundStation is always a ground object.
-     */
-    isGroundObject(): boolean;
-    /**
-     * Returns type-specific serialization data.
-     */
-    protected serializeSpecific(): Record<string, unknown>;
-    toString(): string;
-}
-
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
@@ -10383,43 +10355,163 @@ declare class SolarSystem {
     /** Pluto */
     static get pluto(): PlanetBody;
     /**
-     * Gets the count of registered bodies.
+     * Gets the count of registered bodies.
+     */
+    static get count(): number;
+    /**
+     * Clears all registered bodies and resets to uninitialized state.
+     * Primarily for testing purposes.
+     */
+    static reset(): void;
+    /**
+     * Ensures the registry is initialized before access.
+     */
+    private static ensureInitialized_;
+}
+
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare const radecToPosition: (ra: Radians, dec: Radians, r: Kilometers) => Vector3D<Kilometers>;
+declare const radecToVelocity: (ra: Radians, dec: Radians, r: Kilometers, raDot: RadiansPerSecond, decDot: RadiansPerSecond, rDot: KilometersPerSecond) => Vector3D<KilometersPerSecond>;
+declare const normalizeAngle: (a: number, b: number) => number;
+declare const observationDerivative: (xh: number, xl: number, step: number, isAngle?: boolean) => number;
+declare const observationNoiseFromSigmas: (sigmas: number[]) => Matrix;
+
+/**
+ * @author Theodore Kruczek
+ * @description Orbital Object ToolKit (ootk) is a collection of tools for working
+ * with satellites and other orbital objects.
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Many of the classes are based off of the work of @david-rc-dayton and his
+ * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
+ * is licensed under the MIT license.
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Represents a topocentric right ascension and declination observation.
+ *
+ * Topocentric coordinates take into account the observer's exact location on the Earth's surface. This model is crucial
+ * for precise measurements of local astronomical events and nearby celestial objects, where the observer's latitude,
+ * longitude, and altitude can significantly affect the observed position due to parallax. Topocentric coordinates are
+ * particularly important for observations of the Moon, planets, and artificial satellites.
+ */
+declare class RadecTopocentric {
+    epoch: EpochUTC;
+    rightAscension: Radians;
+    declination: Radians;
+    range?: Kilometers | undefined;
+    rightAscensionRate?: (RadiansPerSecond | null) | undefined;
+    declinationRate?: (RadiansPerSecond | null) | undefined;
+    rangeRate?: (KilometersPerSecond | null) | undefined;
+    constructor(epoch: EpochUTC, rightAscension: Radians, declination: Radians, range?: Kilometers | undefined, rightAscensionRate?: (RadiansPerSecond | null) | undefined, declinationRate?: (RadiansPerSecond | null) | undefined, rangeRate?: (KilometersPerSecond | null) | undefined);
+    /**
+     * Create a new RadecTopocentric object, using degrees for the angular values.
+     * @param epoch UTC epoch.
+     * @param rightAscensionDegrees Right-ascension in degrees.
+     * @param declinationDegrees Declination in degrees.
+     * @param range Range in km.
+     * @param rightAscensionRateDegrees Right-ascension rate in degrees per second.
+     * @param declinationRateDegrees Declination rate in degrees per second.
+     * @param rangeRate Range rate in km/s.
+     * @returns A new RadecTopocentric object.
+     */
+    static fromDegrees(epoch: EpochUTC, rightAscensionDegrees: Degrees, declinationDegrees: Degrees, range?: Kilometers, rightAscensionRateDegrees?: DegreesPerSecond, declinationRateDegrees?: DegreesPerSecond, rangeRate?: KilometersPerSecond): RadecTopocentric;
+    /**
+     * Create a new RadecTopocentric object from a J2000 state vector.
+     * @param state Inertial state vector.
+     * @param site Site vector.
+     * @returns A new RadecTopocentric object.
+     */
+    static fromStateVector(state: J2000, site: J2000): RadecTopocentric;
+    /**
+     * Gets the right ascension in degrees.
+     * @returns The right ascension in degrees.
+     */
+    get rightAscensionDegrees(): Degrees;
+    /**
+     * Gets the declination in degrees.
+     * @returns The declination in degrees.
+     */
+    get declinationDegrees(): Degrees;
+    /**
+     * Gets the right ascension rate in degrees per second.
+     * @returns The right ascension rate in degrees per second, or null if it is not available.
+     */
+    get rightAscensionRateDegrees(): DegreesPerSecond | null;
+    /**
+     * Gets the rate of change of declination in degrees per second.
+     * @returns The rate of change of declination in degrees per second, or null if the declination rate is not defined.
+     */
+    get declinationRateDegrees(): DegreesPerSecond | null;
+    /**
+     * Return the position relative to the observer site.
+     *
+     * An optional range value can be passed to override the value contained in this observation.
+     * @param site Observer site.
+     * @param range Range in km.
+     * @returns A Vector3D object.
+     */
+    position(site: J2000, range?: Kilometers): Vector3D<Kilometers>;
+    /**
+     * Return the velocity relative to the observer site.
+     *
+     * An optional range and rangeRate value can be passed to override the values contained in this observation.
+     * @param site Observer site.
+     * @param range Range in km.
+     * @param rangeRate Range rate in km/s.
+     * @returns A Vector3D object.
      */
-    static get count(): number;
+    velocity(site: J2000, range?: Kilometers, rangeRate?: KilometersPerSecond): Vector3D<KilometersPerSecond>;
     /**
-     * Clears all registered bodies and resets to uninitialized state.
-     * Primarily for testing purposes.
+     * Calculates the line of sight vector in the topocentric coordinate system.
+     * The line of sight vector points from the observer's location towards the celestial object.
+     * @returns The line of sight vector as a Vector3D object.
      */
-    static reset(): void;
+    lineOfSight(): Vector3D;
     /**
-     * Ensures the registry is initialized before access.
+     * Calculate the angular distance between this and another RadecTopocentric object.
+     * @param radec - The other RadecTopocentric object.
+     * @param method - The angular distance method to use.
+     * @returns The angular distance.
      */
-    private static ensureInitialized_;
+    angle(radec: RadecTopocentric, method?: AngularDistanceMethod): Radians;
+    /**
+     * Calculate the angular distance between this and another RadecTopocentric object.
+     * @param radec - The other RadecTopocentric object.
+     * @param method - The angular distance method to use.
+     * @returns The angular distance
+     */
+    angleDegrees(radec: RadecTopocentric, method?: AngularDistanceMethod): Degrees;
 }
 
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-declare const radecToPosition: (ra: Radians, dec: Radians, r: Kilometers) => Vector3D<Kilometers>;
-declare const radecToVelocity: (ra: Radians, dec: Radians, r: Kilometers, raDot: RadiansPerSecond, decDot: RadiansPerSecond, rDot: KilometersPerSecond) => Vector3D<KilometersPerSecond>;
-declare const normalizeAngle: (a: number, b: number) => number;
-declare const observationDerivative: (xh: number, xl: number, step: number, isAngle?: boolean) => number;
-declare const observationNoiseFromSigmas: (sigmas: number[]) => Matrix;
-
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
@@ -10573,126 +10665,6 @@ declare class RadecGeocentric {
     angleDegrees(radec: RadecGeocentric, method?: AngularDistanceMethod): Degrees;
 }
 
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Many of the classes are based off of the work of @david-rc-dayton and his
- * Pious Squid library (https://github.com/david-rc-dayton/pious_squid) which
- * is licensed under the MIT license.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * Represents a topocentric right ascension and declination observation.
- *
- * Topocentric coordinates take into account the observer's exact location on the Earth's surface. This model is crucial
- * for precise measurements of local astronomical events and nearby celestial objects, where the observer's latitude,
- * longitude, and altitude can significantly affect the observed position due to parallax. Topocentric coordinates are
- * particularly important for observations of the Moon, planets, and artificial satellites.
- */
-declare class RadecTopocentric {
-    epoch: EpochUTC;
-    rightAscension: Radians;
-    declination: Radians;
-    range?: Kilometers | undefined;
-    rightAscensionRate?: (RadiansPerSecond | null) | undefined;
-    declinationRate?: (RadiansPerSecond | null) | undefined;
-    rangeRate?: (KilometersPerSecond | null) | undefined;
-    constructor(epoch: EpochUTC, rightAscension: Radians, declination: Radians, range?: Kilometers | undefined, rightAscensionRate?: (RadiansPerSecond | null) | undefined, declinationRate?: (RadiansPerSecond | null) | undefined, rangeRate?: (KilometersPerSecond | null) | undefined);
-    /**
-     * Create a new RadecTopocentric object, using degrees for the angular values.
-     * @param epoch UTC epoch.
-     * @param rightAscensionDegrees Right-ascension in degrees.
-     * @param declinationDegrees Declination in degrees.
-     * @param range Range in km.
-     * @param rightAscensionRateDegrees Right-ascension rate in degrees per second.
-     * @param declinationRateDegrees Declination rate in degrees per second.
-     * @param rangeRate Range rate in km/s.
-     * @returns A new RadecTopocentric object.
-     */
-    static fromDegrees(epoch: EpochUTC, rightAscensionDegrees: Degrees, declinationDegrees: Degrees, range?: Kilometers, rightAscensionRateDegrees?: DegreesPerSecond, declinationRateDegrees?: DegreesPerSecond, rangeRate?: KilometersPerSecond): RadecTopocentric;
-    /**
-     * Create a new RadecTopocentric object from a J2000 state vector.
-     * @param state Inertial state vector.
-     * @param site Site vector.
-     * @returns A new RadecTopocentric object.
-     */
-    static fromStateVector(state: J2000, site: J2000): RadecTopocentric;
-    /**
-     * Gets the right ascension in degrees.
-     * @returns The right ascension in degrees.
-     */
-    get rightAscensionDegrees(): Degrees;
-    /**
-     * Gets the declination in degrees.
-     * @returns The declination in degrees.
-     */
-    get declinationDegrees(): Degrees;
-    /**
-     * Gets the right ascension rate in degrees per second.
-     * @returns The right ascension rate in degrees per second, or null if it is not available.
-     */
-    get rightAscensionRateDegrees(): DegreesPerSecond | null;
-    /**
-     * Gets the rate of change of declination in degrees per second.
-     * @returns The rate of change of declination in degrees per second, or null if the declination rate is not defined.
-     */
-    get declinationRateDegrees(): DegreesPerSecond | null;
-    /**
-     * Return the position relative to the observer site.
-     *
-     * An optional range value can be passed to override the value contained in this observation.
-     * @param site Observer site.
-     * @param range Range in km.
-     * @returns A Vector3D object.
-     */
-    position(site: J2000, range?: Kilometers): Vector3D<Kilometers>;
-    /**
-     * Return the velocity relative to the observer site.
-     *
-     * An optional range and rangeRate value can be passed to override the values contained in this observation.
-     * @param site Observer site.
-     * @param range Range in km.
-     * @param rangeRate Range rate in km/s.
-     * @returns A Vector3D object.
-     */
-    velocity(site: J2000, range?: Kilometers, rangeRate?: KilometersPerSecond): Vector3D<KilometersPerSecond>;
-    /**
-     * Calculates the line of sight vector in the topocentric coordinate system.
-     * The line of sight vector points from the observer's location towards the celestial object.
-     * @returns The line of sight vector as a Vector3D object.
-     */
-    lineOfSight(): Vector3D;
-    /**
-     * Calculate the angular distance between this and another RadecTopocentric object.
-     * @param radec - The other RadecTopocentric object.
-     * @param method - The angular distance method to use.
-     * @returns The angular distance.
-     */
-    angle(radec: RadecTopocentric, method?: AngularDistanceMethod): Radians;
-    /**
-     * Calculate the angular distance between this and another RadecTopocentric object.
-     * @param radec - The other RadecTopocentric object.
-     * @param method - The angular distance method to use.
-     * @returns The angular distance
-     */
-    angleDegrees(radec: RadecTopocentric, method?: AngularDistanceMethod): Degrees;
-}
-
 /**
  * @author Theodore Kruczek
  * @description Orbital Object ToolKit (ootk) is a collection of tools for working
@@ -11377,90 +11349,47 @@ declare class RkResult {
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
  * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-declare class RungeKutta4Propagator extends Propagator {
-    private readonly initState_;
-    private forceModel_;
-    private stepSize_;
-    private cacheState_;
-    private checkpoints_;
-    /**
-     * Create a new [RungeKutta4Propagator] object from an initial state vector and
-     * along with an optional [ForceModel] and [stepSize] in seconds.
-     * @param initState_ Initial state vector.
-     * @param forceModel_ Numerical integration force model.
-     * @param stepSize_ Integration step size _(seconds)_.
-     * @param cacheState_ Cached state vector.
-     * @param checkpoints_ Cached state vector checkpoints.
-     */
-    constructor(initState_: J2000, forceModel_?: ForceModel, stepSize_?: number, cacheState_?: J2000, checkpoints_?: J2000[]);
-    setStepSize(seconds: number): void;
-    setForceModel(forceModel: ForceModel): void;
-    ephemerisManeuver(start: EpochUTC, finish: EpochUTC, maneuvers: Thrust[], interval?: Seconds): VerletBlendInterpolator;
-    maneuver(maneuver: Thrust, interval?: number): J2000[];
-    private _kFn;
-    private _integrate;
-    propagate(epoch: EpochUTC): J2000;
-    reset(): void;
-    get state(): J2000;
-    checkpoint(): number;
-    clearCheckpoints(): void;
-    restore(index: number): void;
-}
-
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/** Covariance Frame */
-declare enum CovarianceFrame {
-    /** Earth-centered inertial */
-    ECI = "eci",
-    /** Radial-Intrack-Crosstrack */
-    RIC = "ric"
-}
-declare class StateCovariance {
-    matrix: Matrix;
-    frame: CovarianceFrame;
-    /**
-     * Create a new [StateCovariance] object given its covariance [matrix] and
-     * [CovarianceFrame].
-     * @param matrix The covariance matrix.
-     * @param frame The covariance frame.
-     * @returns A new [StateCovariance] object.
-     */
-    constructor(matrix: Matrix, frame: CovarianceFrame);
-    static fromSigmas(sigmas: number[], frame: CovarianceFrame): StateCovariance;
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+declare class RungeKutta4Propagator extends Propagator {
+    private readonly initState_;
+    private forceModel_;
+    private stepSize_;
+    private cacheState_;
+    private checkpoints_;
     /**
-     * Calculates the standard deviations (sigmas) of each element in the covariance matrix.
-     * @returns A vector containing the standard deviations of each element in the covariance matrix.
+     * Create a new [RungeKutta4Propagator] object from an initial state vector and
+     * along with an optional [ForceModel] and [stepSize] in seconds.
+     * @param initState_ Initial state vector.
+     * @param forceModel_ Numerical integration force model.
+     * @param stepSize_ Integration step size _(seconds)_.
+     * @param cacheState_ Cached state vector.
+     * @param checkpoints_ Cached state vector checkpoints.
      */
-    sigmas(): Vector;
+    constructor(initState_: J2000, forceModel_?: ForceModel, stepSize_?: number, cacheState_?: J2000, checkpoints_?: J2000[]);
+    setStepSize(seconds: number): void;
+    setForceModel(forceModel: ForceModel): void;
+    ephemerisManeuver(start: EpochUTC, finish: EpochUTC, maneuvers: Thrust[], interval?: Seconds): VerletBlendInterpolator;
+    maneuver(maneuver: Thrust, interval?: number): J2000[];
+    private _kFn;
+    private _integrate;
+    propagate(epoch: EpochUTC): J2000;
+    reset(): void;
+    get state(): J2000;
+    checkpoint(): number;
+    clearCheckpoints(): void;
+    restore(index: number): void;
 }
 
 /**
@@ -12142,6 +12071,113 @@ interface RicSigmas {
  */
 declare function scaleAndClampRicSigmas(sigmas: RicSigmas, confidence: number, caps: RicSigmas): RicSigmas | null;
 
+/**
+ * @author Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2025-2026 Kruczek Labs LLC
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Represents the result of a conjunction assessment between two space objects.
+ * Contains all relevant information about the close approach event.
+ */
+declare class ConjunctionEvent {
+    /** Time of Closest Approach (TCA) */
+    readonly tca: EpochUTC;
+    /** Primary object state at TCA in J2000 frame */
+    readonly primaryState: J2000;
+    /** Secondary object state at TCA in J2000 frame */
+    readonly secondaryState: J2000;
+    /** Relative state in RIC frame (relative to primary) */
+    readonly relativeState: RIC;
+    /** Total miss distance at TCA (km) */
+    readonly missDistance: Kilometers;
+    /** Radial component of miss distance (km) */
+    readonly radialDistance: Kilometers;
+    /** Intrack component of miss distance (km) */
+    readonly intrackDistance: Kilometers;
+    /** Crosstrack component of miss distance (km) */
+    readonly crosstrackDistance: Kilometers;
+    /** Relative velocity magnitude at TCA (km/s) */
+    readonly relativeVelocity: KilometersPerSecond;
+    /** Combined position covariance matrix in RIC frame (optional) */
+    readonly combinedCovariance?: StateCovariance;
+    /** Probability of collision (optional, 0-1) */
+    readonly probabilityOfCollision?: number;
+    /** Hard body radius for primary object (km, optional) */
+    readonly primaryRadius?: Kilometers;
+    /** Hard body radius for secondary object (km, optional) */
+    readonly secondaryRadius?: Kilometers;
+    /** Primary object name/identifier (optional, for CDM export) */
+    readonly primaryName?: string;
+    /** Secondary object name/identifier (optional, for CDM export) */
+    readonly secondaryName?: string;
+    /** Primary object catalog designator (optional, for CDM export) */
+    readonly primaryDesignator?: string;
+    /** Secondary object catalog designator (optional, for CDM export) */
+    readonly secondaryDesignator?: string;
+    /** Primary object covariance (optional, for CDM export) */
+    readonly primaryCovariance?: StateCovariance;
+    /** Secondary object covariance (optional, for CDM export) */
+    readonly secondaryCovariance?: StateCovariance;
+    constructor(params: {
+        tca: EpochUTC;
+        primaryState: J2000;
+        secondaryState: J2000;
+        relativeState: RIC;
+        missDistance: Kilometers;
+        radialDistance: Kilometers;
+        intrackDistance: Kilometers;
+        crosstrackDistance: Kilometers;
+        relativeVelocity: KilometersPerSecond;
+        combinedCovariance?: StateCovariance;
+        probabilityOfCollision?: number;
+        primaryRadius?: Kilometers;
+        secondaryRadius?: Kilometers;
+        primaryName?: string;
+        secondaryName?: string;
+        primaryDesignator?: string;
+        secondaryDesignator?: string;
+        primaryCovariance?: StateCovariance;
+        secondaryCovariance?: StateCovariance;
+    });
+    /**
+     * Returns a formatted string representation of the conjunction event.
+     * @returns A multi-line string with conjunction details.
+     */
+    toString(): string;
+    /**
+     * Checks if this is a high-risk conjunction based on miss distance and Pc.
+     * @param distanceThreshold Miss distance threshold in km (default: 1.0 km)
+     * @param pcThreshold Probability of collision threshold (default: 1e-4)
+     * @returns True if the conjunction exceeds risk thresholds.
+     */
+    isHighRisk(distanceThreshold?: Kilometers, pcThreshold?: number): boolean;
+    /**
+     * Gets the Mahalanobis distance if covariance is available.
+     * This is the miss distance normalized by the combined covariance.
+     * @returns The Mahalanobis distance (unitless), or undefined if no covariance.
+     */
+    getMahalanobisDistance(): number | undefined;
+    /**
+     * Extracts the 3x3 position covariance from a 6x6 state covariance matrix.
+     * @param stateCov 6x6 state covariance matrix
+     * @returns 3x3 position covariance matrix
+     */
+    private extractPositionCovariance;
+}
+
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later
@@ -12292,113 +12328,6 @@ declare class ConjunctionAssessment {
     private build6x6Transform;
 }
 
-/**
- * @author Theodore Kruczek
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025-2026 Kruczek Labs LLC
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * Represents the result of a conjunction assessment between two space objects.
- * Contains all relevant information about the close approach event.
- */
-declare class ConjunctionEvent {
-    /** Time of Closest Approach (TCA) */
-    readonly tca: EpochUTC;
-    /** Primary object state at TCA in J2000 frame */
-    readonly primaryState: J2000;
-    /** Secondary object state at TCA in J2000 frame */
-    readonly secondaryState: J2000;
-    /** Relative state in RIC frame (relative to primary) */
-    readonly relativeState: RIC;
-    /** Total miss distance at TCA (km) */
-    readonly missDistance: Kilometers;
-    /** Radial component of miss distance (km) */
-    readonly radialDistance: Kilometers;
-    /** Intrack component of miss distance (km) */
-    readonly intrackDistance: Kilometers;
-    /** Crosstrack component of miss distance (km) */
-    readonly crosstrackDistance: Kilometers;
-    /** Relative velocity magnitude at TCA (km/s) */
-    readonly relativeVelocity: KilometersPerSecond;
-    /** Combined position covariance matrix in RIC frame (optional) */
-    readonly combinedCovariance?: StateCovariance;
-    /** Probability of collision (optional, 0-1) */
-    readonly probabilityOfCollision?: number;
-    /** Hard body radius for primary object (km, optional) */
-    readonly primaryRadius?: Kilometers;
-    /** Hard body radius for secondary object (km, optional) */
-    readonly secondaryRadius?: Kilometers;
-    /** Primary object name/identifier (optional, for CDM export) */
-    readonly primaryName?: string;
-    /** Secondary object name/identifier (optional, for CDM export) */
-    readonly secondaryName?: string;
-    /** Primary object catalog designator (optional, for CDM export) */
-    readonly primaryDesignator?: string;
-    /** Secondary object catalog designator (optional, for CDM export) */
-    readonly secondaryDesignator?: string;
-    /** Primary object covariance (optional, for CDM export) */
-    readonly primaryCovariance?: StateCovariance;
-    /** Secondary object covariance (optional, for CDM export) */
-    readonly secondaryCovariance?: StateCovariance;
-    constructor(params: {
-        tca: EpochUTC;
-        primaryState: J2000;
-        secondaryState: J2000;
-        relativeState: RIC;
-        missDistance: Kilometers;
-        radialDistance: Kilometers;
-        intrackDistance: Kilometers;
-        crosstrackDistance: Kilometers;
-        relativeVelocity: KilometersPerSecond;
-        combinedCovariance?: StateCovariance;
-        probabilityOfCollision?: number;
-        primaryRadius?: Kilometers;
-        secondaryRadius?: Kilometers;
-        primaryName?: string;
-        secondaryName?: string;
-        primaryDesignator?: string;
-        secondaryDesignator?: string;
-        primaryCovariance?: StateCovariance;
-        secondaryCovariance?: StateCovariance;
-    });
-    /**
-     * Returns a formatted string representation of the conjunction event.
-     * @returns A multi-line string with conjunction details.
-     */
-    toString(): string;
-    /**
-     * Checks if this is a high-risk conjunction based on miss distance and Pc.
-     * @param distanceThreshold Miss distance threshold in km (default: 1.0 km)
-     * @param pcThreshold Probability of collision threshold (default: 1e-4)
-     * @returns True if the conjunction exceeds risk thresholds.
-     */
-    isHighRisk(distanceThreshold?: Kilometers, pcThreshold?: number): boolean;
-    /**
-     * Gets the Mahalanobis distance if covariance is available.
-     * This is the miss distance normalized by the combined covariance.
-     * @returns The Mahalanobis distance (unitless), or undefined if no covariance.
-     */
-    getMahalanobisDistance(): number | undefined;
-    /**
-     * Extracts the 3x3 position covariance from a 6x6 state covariance matrix.
-     * @param stateCov 6x6 state covariance matrix
-     * @returns 3x3 position covariance matrix
-     */
-    private extractPositionCovariance;
-}
-
 /**
  * @author Theodore Kruczek
  * @license AGPL-3.0-or-later