@interstellar-tools/types 0.1.1

package/dist/celestial-bodies/planets.d.ts

@@ -0,0 +1,96 @@
+import { DistanceInterface, MeasureInterface } from '../distance';
+import { Radians } from '../numeric';
+import { TemporalInterface } from '../temporal';
+/**
+ * Represents **2D coordinates** for planetary positioning.
+ *
+ * @property {number} x - The x-coordinate.
+ * @property {number} y - The y-coordinate.
+ *
+ * @example
+ * ```ts
+ * const position: CartesianCoordinatesInterface = { x: 100, y: 200 };
+ * ```
+ * @category Celestial Bodies
+ */
+export interface CartesianCoordinatesInterface {
+    x: number;
+    y: number;
+}
+/**
+ * Represents a **planet** in the solar system simulation.
+ *
+ * **Orbital Properties:**
+ * - **Semi-major axis (`a`)**: Defines the planet’s orbit size in **Astronomical Units (AU)**.
+ * - **Orbital eccentricity (`e`)**: Determines how elliptical the orbit is ($0 =$ circular, closer to $1 =$ highly elliptical).
+ * - **Orbital period (`period`)**: Time taken for one full orbit in **Earth days**.
+ * - **True anomaly (`angle`)**: The planet’s current position in its orbit (in **radians**).
+ *
+ * **Classification & Visualization:**
+ * - **Type (`type`)**: Scientific classification of the planet (e.g., **terrestrial, gas giant, ice planet**).
+ * - **Category (`category`)**: Defines whether the object is a **planet** or a **planetoid**.
+ * - **Color (`color`)**: Used for visual representation in simulations.
+ * - **Size (`radius`)**: Physical planet radius in **kilometers (km)**.
+ *
+ * @example
+ * ```ts
+ * const earth: PlanetInterface = {
+ *   name: 'Earth',
+ *   type: 'terrestrial planet',
+ *   category: 'planet',
+ *   color: '#4287f5',
+ *   system: 'Sun',
+ *   radius: { value: 6371, unit: 'km' },
+ *   a: { value: 1.0, unit: 'au' },
+ *   e: 0.0167,
+ *   period: { value: 365.25, unit: 'd' },
+ *   angle: 0,
+ *   x: { value: 0, unit: 'au' },
+ *   y: { value: 1, unit: 'au' },
+ *   z: { value: 0, unit: 'au' }
+ * };
+ * ```
+ * @category Celestial Bodies
+ */
+export interface PlanetInterface {
+    /** Name of the planet (e.g., "Earth", "Mars"). */
+    name: string;
+    /** Type classification of the planet. */
+    type: 'chthonian planet' | 'carbon planet' | 'coreless planet' | 'desert planet' | 'gas dwarf' | 'gas giant' | 'helium planet' | 'hycean planet' | 'ice giant' | 'ice planet' | 'iron planet' | 'lava planet' | 'ocean planet' | 'proto planet' | 'puffy planet' | 'super-puff' | 'silicate planet' | 'terrestrial planet';
+    /** Defines whether the object is a planet or a planetoid. */
+    category: 'planet' | 'planetoid';
+    /** Visual representation color. */
+    color: string;
+    /** The planetary system in which the planet exists. */
+    system: string;
+    /** Physical radius of the planet in kilometres. */
+    radius: DistanceInterface;
+    /** Semi-major axis of the orbit in AU. */
+    a: MeasureInterface;
+    /** Orbital eccentricity (0 = circular, closer to 1 = highly elliptical). */
+    e: number;
+    /** Semi-minor axis of the orbit (calculated from `a` and `e`). */
+    miA?: number;
+    /** X-offset for the ellipse focus (accounts for eccentricity). */
+    focus_x?: number;
+    /** Current orbital position in radians (True Anomaly). */
+    angle: Radians;
+    /** X-coordinate in a distance-based system. */
+    x: DistanceInterface;
+    /** Y-coordinate in a distance-based system. */
+    y: DistanceInterface;
+    /** Z-coordinate in a distance-based system. */
+    z: DistanceInterface;
+    /** Orbital period in Earth days. Negative values indicate counter clockwise orbit */
+    period: TemporalInterface;
+    /** Precomputed orbital path points for visualization (optional). */
+    orbitPath?: CartesianCoordinatesInterface[];
+}
+/**
+ * Type alias for a collection of **planets**.
+ *
+ * @typedef {PlanetInterface[]} PlanetsType
+ * @category Celestial Bodies
+ */
+export type PlanetsType = PlanetInterface[];
+//# sourceMappingURL=planets.d.ts.map

package/dist/celestial-bodies/planets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planets.d.ts","sourceRoot":"","sources":["../../src/celestial-bodies/planets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,6BAA6B;IAC5C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,IAAI,EACA,kBAAkB,GAClB,eAAe,GACf,iBAAiB,GACjB,eAAe,GACf,WAAW,GACX,WAAW,GACX,eAAe,GACf,eAAe,GACf,WAAW,GACX,YAAY,GACZ,aAAa,GACb,aAAa,GACb,cAAc,GACd,cAAc,GACd,cAAc,GACd,YAAY,GACZ,iBAAiB,GACjB,oBAAoB,CAAC;IACzB,6DAA6D;IAC7D,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC;IACjC,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,0CAA0C;IAC1C,CAAC,EAAE,gBAAgB,CAAC;IACpB,4EAA4E;IAC5E,CAAC,EAAE,MAAM,CAAC;IACV,kEAAkE;IAClE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,KAAK,EAAE,OAAO,CAAC;IACf,+CAA+C;IAC/C,CAAC,EAAE,iBAAiB,CAAC;IACrB,+CAA+C;IAC/C,CAAC,EAAE,iBAAiB,CAAC;IACrB,+CAA+C;IAC/C,CAAC,EAAE,iBAAiB,CAAC;IACrB,qFAAqF;IACrF,MAAM,EAAE,iBAAiB,CAAC;IAC1B,oEAAoE;IACpE,SAAS,CAAC,EAAE,6BAA6B,EAAE,CAAC;CAC7C;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,eAAe,EAAE,CAAC"}

package/dist/celestial-bodies/planets.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=planets.js.map

package/dist/celestial-bodies/planets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planets.js","sourceRoot":"","sources":["../../src/celestial-bodies/planets.ts"],"names":[],"mappings":""}

package/dist/celestial-bodies/stars.d.ts

@@ -0,0 +1,100 @@
+import { DistanceInterface, MeasureInterface } from '../distance';
+import { Radians } from '../numeric';
+import { TemporalInterface } from '../temporal';
+import { CartesianCoordinatesInterface } from './planets';
+/**
+ * Represents a **star system**, which can be a planetary system or a stellar system.
+ *
+ * @property {string} name - Name of the star system.
+ * @property {'planetary system' | 'stellar system'} type - Specifies if it is a **planetary system** or a **stellar system**.
+ *
+ * @example
+ * ```ts
+ * const solarSystem: StarSystemInterface = {
+ *   name: 'Solar System',
+ *   type: 'planetary system'
+ * };
+ * ```
+ * @category Celestial Bodies
+ */
+export interface StarSystemInterface {
+    name: string;
+    type: 'planetary system' | 'stellar system';
+}
+/**
+ * Represents a **star** in a planetary or stellar system.
+ *
+ * **Orbital & Physical Properties:**
+ * - **Semi-major axis (`a`)**: Defines the star’s orbit size (AU or light-years).
+ * - **Orbital eccentricity (`e`)**: Determines how elliptical the orbit is.
+ * - **Orbital period (`period`)**: Time taken for one full orbit. Negative values indicates counter clockwise direction.
+ * - **True anomaly (`angle`)**: The star’s current position in its orbit (in **radians**).
+ * - **Radius (`radius`)**: Physical size of the star.
+ *
+ * **Classification & Visualization:**
+ * - **Type (`type`)**: Classification of the star (e.g., **main-sequence star, white dwarf**).
+ * - **Category (`category`)**: Defined as `'star'`.
+ * - **Color (`color`)**: Used for visual representation.
+ *
+ * @example
+ * ```ts
+ * const sun: StarInterface = {
+ *   name: 'Sun',
+ *   type: 'G-type main-sequence',
+ *   category: 'star',
+ *   system: solarSystem,
+ *   radius: { value: 695700, unit: 'km' },
+ *   color: '#ffcc00',
+ *   a: { value: 0, unit: 'au' },
+ *   e: 0,
+ *   period: { value: 0, unit: 'years' },
+ *   angle: 0,
+ *   x: { value: 0, unit: 'au' },
+ *   y: { value: 0, unit: 'au' },
+ *   z: { value: 0, unit: 'au' }
+ * };
+ * ```
+ * @category Celestial Bodies
+ */
+export interface StarInterface {
+    /** Name of the star. */
+    name: string;
+    /** Classification of the star (e.g., main-sequence, red giant, white dwarf). */
+    type: string;
+    /** Defines the category as a star. */
+    category: 'star';
+    /** The system in which the star exists. */
+    system: StarSystemInterface;
+    /** Physical radius of the star. */
+    radius: DistanceInterface;
+    /** Visual representation color. */
+    color: string;
+    /** Semi-major axis of the orbit (AU or light-years). */
+    a: MeasureInterface;
+    /** Orbital eccentricity (0 = circular, closer to 1 = highly elliptical). */
+    e: number;
+    /** Semi-minor axis of the orbit (calculated from `a` and `e`). */
+    miA?: number;
+    /** X-offset for the ellipse focus (accounts for eccentricity). */
+    focus_x?: number;
+    /** Current orbital position in radians (True Anomaly). */
+    angle: Radians;
+    /** X-coordinate in a distance-based system. */
+    x: DistanceInterface;
+    /** Y-coordinate in a distance-based system. */
+    y: DistanceInterface;
+    /** Z-coordinate in a distance-based system. */
+    z: DistanceInterface;
+    /** Orbital period of the star. Negative values indicate counter clockwise direction. */
+    period: TemporalInterface;
+    /** Precomputed orbital path points for visualization (optional). */
+    orbitPath?: CartesianCoordinatesInterface[];
+}
+/**
+ * Type alias for a collection of **stars**.
+ *
+ * @typedef {StarInterface[]} StarsType
+ * @category Celestial Bodies
+ */
+export type StarsType = StarInterface[];
+//# sourceMappingURL=stars.d.ts.map

package/dist/celestial-bodies/stars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stars.d.ts","sourceRoot":"","sources":["../../src/celestial-bodies/stars.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,6BAA6B,EAAE,MAAM,WAAW,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,GAAG,gBAAgB,CAAC;CAC7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,aAAa;IAC5B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,MAAM,EAAE,mBAAmB,CAAC;IAC5B,mCAAmC;IACnC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,CAAC,EAAE,gBAAgB,CAAC;IACpB,4EAA4E;IAC5E,CAAC,EAAE,MAAM,CAAC;IACV,kEAAkE;IAClE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,KAAK,EAAE,OAAO,CAAC;IACf,+CAA+C;IAC/C,CAAC,EAAE,iBAAiB,CAAC;IACrB,+CAA+C;IAC/C,CAAC,EAAE,iBAAiB,CAAC;IACrB,+CAA+C;IAC/C,CAAC,EAAE,iBAAiB,CAAC;IACrB,wFAAwF;IACxF,MAAM,EAAE,iBAAiB,CAAC;IAC1B,oEAAoE;IACpE,SAAS,CAAC,EAAE,6BAA6B,EAAE,CAAC;CAC7C;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,EAAE,CAAC"}

package/dist/celestial-bodies/stars.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stars.js.map

package/dist/celestial-bodies/stars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stars.js","sourceRoot":"","sources":["../../src/celestial-bodies/stars.ts"],"names":[],"mappings":""}

package/dist/celestial-bodies/systems.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Represents a star system within the space visualization.
+ * @category Celestial Bodies
+ */
+export interface SystemInterface {
+    /** Name of the star system. */
+    name: string;
+    /** List of star names in the system. */
+    stars: string[];
+    /** Distance from the Sun in light-years. */
+    distance: number;
+}
+/**
+ * Type alias for a collection of star systems.
+ * @category Celestial Bodies
+ */
+export type SystemsType = SystemInterface[];
+//# sourceMappingURL=systems.d.ts.map

package/dist/celestial-bodies/systems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"systems.d.ts","sourceRoot":"","sources":["../../src/celestial-bodies/systems.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,eAAe,EAAE,CAAC"}

package/dist/celestial-bodies/systems.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=systems.js.map

package/dist/celestial-bodies/systems.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"systems.js","sourceRoot":"","sources":["../../src/celestial-bodies/systems.ts"],"names":[],"mappings":""}

package/dist/distance.d.ts

@@ -0,0 +1,111 @@
+import { ValueInterface } from './numeric';
+/**
+ * @showCategories
+ * @module
+ */
+/**
+ * Canonical **distance unit symbols** for astronomy/space visualization.
+ *
+ * ## Design principles
+ * - **Canonical symbols only** (no plurals / long names) for stable math & serialization.
+ * - Uses **meters** as the [SI](https://en.wikipedia.org/wiki/International_System_of_Units) base; larger units have conventional scientific definitions.
+ *
+ * ## Conventions
+ * - **`au`** — Astronomical Unit (IAU 2012 B2): **149 597 870 700 m** (lowercase `au` is the IAU symbol).
+ * - **`ly` family** — Light-year based on the **Julian year**:
+ *   `1 ly = c × 365.25 d = 9 460 730 472 580 800 m` (with `kly = 10³ ly`, `Mly = 10⁶ ly`, `Gly = 10⁹ ly`).
+ * - **`pc` family** — Parsec defined from the arcsecond parallax:
+ *   `1 pc = au × (648000 / π) ≈ 3.085677581×10¹⁶ m` (`kpc/Mpc/Gpc` are ×10³/×10⁶/×10⁹).
+ *
+ * ## Members
+ * - [SI](https://en.wikipedia.org/wiki/International_System_of_Units) base & common multiple: `m`, `km`
+ * - Astronomical: `au`
+ * - Light-year family: `ly`, `kly`, `Mly`, `Gly`
+ * - Parsec family: `pc`, `kpc`, `Mpc`, `Gpc`
+ *
+ * @example
+ * ```ts
+ * // Example shape often used alongside this type:
+ * type Distance = { value: number; unit: DistanceUnitType };
+ *
+ * const d1: Distance = { value: 1, unit: 'au' };
+ * const d2: Distance = { value: 3.26, unit: 'ly' };
+ * const d3: Distance = { value: 8, unit: 'kpc' };
+ * ```
+ *
+ * @see https://www.iau.org/static/resolutions/IAU2012_English.pdf (IAU 2012 B2 — definition of the astronomical unit)
+ * @see https://en.wikipedia.org/wiki/Light-year (Light-year based on Julian year)
+ * @see https://en.wikipedia.org/wiki/Parsec (Parsec definition & meter equivalence)
+ * @category Distance
+ */
+export type DistanceUnitType = 'm' | 'km' | 'au' | 'ly' | 'kly' | 'Mly' | 'Gly' | 'pc' | 'kpc' | 'Mpc' | 'Gpc';
+/**
+ * Human-friendly **distance unit aliases** accepted at input time.
+ *
+ * These strings should be parsed and **normalized** to canonical {@link DistanceUnitType}
+ * (e.g., `"AU"` → `"au"`, `"lightyears"` → `"ly"`, `"kiloparsecs"` → `"kpc"`).
+ *
+ * ## Scope & conventions
+ * - **Canonical vs. aliases**: This type is for *inputs*. Convert to canonical symbols
+ *   (`m`, `km`, `au`, `ly/kly/Mly/Gly`, `pc/kpc/Mpc/Gpc`) before math or serialization.
+ * - **Case-sensitive** and **exact** matches: tokens are matched exactly as listed here.
+ *   For example, `"AU"` is valid (alias) while `"au"` is the canonical symbol (not part of this alias type).
+ * - **IAU symbol**: canonical astronomical unit is lowercase **`au`**; we accept `"AU"`, `"Au"`,
+ *   and textual forms as aliases.
+ * - **Light-year and parsec families**: long names (with/without hyphens) normalize to their
+ *   canonical symbols (`ly/kly/Mly/Gly`, `pc/kpc/Mpc/Gpc`). By convention, `ly` uses the
+ *   **Julian year** (consistent with your temporal units).
+ *
+ * ### Typical flow
+ * 1) Accept `DistanceUnitAliasType | DistanceUnitType` at your API boundary.
+ * 2) Normalize to `DistanceUnitType` (e.g., via `normalizeDistanceUnit`).
+ * 3) Perform calculations using canonical units only.
+ *
+ * @example
+ * ```ts
+ * // Assuming `normalizeDistanceUnit` and `NORMALIZE_DISTANCE_UNIT` are defined:
+ * normalizeDistanceUnit('AU');           // 'au'
+ * normalizeDistanceUnit('lightyears');   // 'ly'
+ * normalizeDistanceUnit('kilolightyears'); // 'kly'
+ * normalizeDistanceUnit('parsecs');      // 'pc'
+ * normalizeDistanceUnit('Mpc');          // 'Mpc' (already canonical)
+ * ```
+ *
+ * @see DistanceUnitType for the canonical symbol set.
+ * @see https://www.iau.org/static/resolutions/IAU2012_English.pdf (IAU 2012 B2 — astronomical unit, symbol "au")
+ * @see https://en.wikipedia.org/wiki/Light-year (Light-year; Julian-year convention)
+ * @see https://en.wikipedia.org/wiki/Parsec (Parsec definition)
+ * @category Distance
+ */
+export type DistanceUnitAliasType = 'meter' | 'meters' | 'metre' | 'metres' | 'kilometer' | 'kilometers' | 'kilometre' | 'kilometres' | 'AU' | 'Au' | 'astronomical-unit' | 'astronomical-units' | 'astronomical unit' | 'astronomical units' | 'lightyear' | 'lightyears' | 'light-year' | 'light-years' | 'kilolightyear' | 'kilolightyears' | 'kly' | 'megalightyear' | 'megalightyears' | 'Mly' | 'gigalightyear' | 'gigalightyears' | 'Gly' | 'parsec' | 'parsecs' | 'kiloparsec' | 'kiloparsecs' | 'kpc' | 'megaparsec' | 'megaparsecs' | 'Mpc' | 'gigaparsec' | 'gigaparsecs' | 'Gpc';
+/**
+ * Represents a measurement with an associated unit.
+ *
+ * @extends ValueInterface
+ * @property {DistanceUnitType} unit - The unit of measurement.
+ *
+ * @example
+ * ```ts
+ * const planetRadius: MeasureInterface = { value: 6371, unit: 'km' };
+ * ```
+ * @category Distance
+ */
+export interface MeasureInterface extends ValueInterface {
+    unit: DistanceUnitType;
+}
+/**
+ * Represents a distance measurement with an associated unit.
+ *
+ * @extends ValueInterface
+ * @property {DistanceUnitType} unit - The unit of distance measurement.
+ *
+ * @example
+ * ```ts
+ * const distanceToAlphaCentauri: DistanceInterface = { value: 4.367, unit: 'lightyears' };
+ * ```
+ * @category Distance
+ */
+export interface DistanceInterface extends ValueInterface {
+    unit: DistanceUnitType;
+}
+//# sourceMappingURL=distance.d.ts.map

package/dist/distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance.d.ts","sourceRoot":"","sources":["../src/distance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,gBAAgB,GACxB,GAAG,GACH,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,KAAK,GACL,KAAK,GACL,IAAI,GACJ,KAAK,GACL,KAAK,GACL,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,MAAM,qBAAqB,GAE7B,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GAER,WAAW,GACX,YAAY,GACZ,WAAW,GACX,YAAY,GAEZ,IAAI,GACJ,IAAI,GACJ,mBAAmB,GACnB,oBAAoB,GACpB,mBAAmB,GACnB,oBAAoB,GAEpB,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,eAAe,GACf,gBAAgB,GAChB,KAAK,GACL,eAAe,GACf,gBAAgB,GAChB,KAAK,GACL,eAAe,GACf,gBAAgB,GAChB,KAAK,GAEL,QAAQ,GACR,SAAS,GACT,YAAY,GACZ,aAAa,GACb,KAAK,GACL,YAAY,GACZ,aAAa,GACb,KAAK,GACL,YAAY,GACZ,aAAa,GACb,KAAK,CAAC;AAEV;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD,IAAI,EAAE,gBAAgB,CAAC;CACxB"}

package/dist/distance.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=distance.js.map

package/dist/distance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance.js","sourceRoot":"","sources":["../src/distance.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './distance';
+export * from './temporal';
+export * from './numeric';
+export * from './celestial-bodies';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAE3B,cAAc,YAAY,CAAC;AAE3B,cAAc,WAAW,CAAC;AAE1B,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './distance';
+export * from './temporal';
+export * from './numeric';
+export * from './celestial-bodies';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAE3B,cAAc,YAAY,CAAC;AAE3B,cAAc,WAAW,CAAC;AAE1B,cAAc,oBAAoB,CAAC"}

package/dist/numeric.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @showCategories
+ * @module
+ */
+/**
+ * Represents a numerical value.
+ *
+ * @property {number} value - The numeric value of the measurement.
+ *
+ * @example
+ * ```ts
+ * const distance: ValueInterface = { value: 100 };
+ * ```
+ * @category Numeric
+ */
+export interface ValueInterface {
+    value: number;
+}
+/**
+ * Type alias representing an angle in **radians**.
+ *
+ * @typedef {number} Radians
+ *
+ * @example
+ * ```ts
+ * const angle: Radians = Math.PI / 2; // 90 degrees in radians
+ * ```
+ * @category Numeric
+ */
+export type Radians = number;
+//# sourceMappingURL=numeric.d.ts.map

package/dist/numeric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../src/numeric.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC"}

package/dist/numeric.js

@@ -0,0 +1,6 @@
+/**
+ * @showCategories
+ * @module
+ */
+export {};
+//# sourceMappingURL=numeric.js.map

package/dist/numeric.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.js","sourceRoot":"","sources":["../src/numeric.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/temporal.d.ts

@@ -0,0 +1,100 @@
+import { ValueInterface } from './numeric';
+/**
+ * @showCategories
+ * @module
+ */
+/**
+ * Canonical **temporal unit symbols** for spacetime/physics **durations**.
+ *
+ * ## Design principles
+ * - **Canonical symbols only** (no plurals): stable for math and serialization.
+ * - **Durations, not timestamps/"ago"** semantics.
+ * - **Days** are the [SI](https://en.wikipedia.org/wiki/International_System_of_Units) day: exactly **86 400 s**.
+ * - **Years** are the **Julian year** (astronomy) by convention: **365.25 d = 31 557 600 s**.
+ *   This keeps `yr/kyr/Myr/Gyr` numerically crisp for large-scale calculations.
+ * - Microseconds use the Unicode micro sign **`μs`**. If your environment is ASCII-only,
+ *   normalize external inputs (e.g. `"us"` → `"μs"`) **before** using this type.
+ *
+ * ## Members
+ * - Subsecond [SI](https://en.wikipedia.org/wiki/International_System_of_Units): `ms`, `μs`, `ns`, `ps`, `fs`, `as`, `zs`, `ys`
+ * - Base [SI](https://en.wikipedia.org/wiki/International_System_of_Units): `s`
+ * - Convenient larger units: `min`, `h`, `d`
+ * - Astronomical year family (durations): `yr`, `kyr`, `Myr`, `Gyr`
+ *
+ * ::: info
+ *
+ * If you need to accept user-friendly aliases (e.g. `"seconds"`, `"us"`, `"hours"`),
+ * map them to these canonical symbols in a normalization step outside this type.
+ *
+ * :::
+ *
+ * @see https://www.bipm.org/en/publications/si-brochure  ([SI](https://en.wikipedia.org/wiki/International_System_of_Units) Brochure — second & day)
+ * @see https://en.wikipedia.org/wiki/Julian_year_(astronomy) (Julian year used for `yr`)
+ * @category Temporal
+ */
+export type TemporalUnitType = 's' | 'ms' | 'μs' | 'ns' | 'ps' | 'fs' | 'as' | 'zs' | 'ys' | 'min' | 'h' | 'd' | 'yr' | 'kyr' | 'Myr' | 'Gyr';
+/**
+ * Human-friendly **temporal unit aliases** accepted at input time.
+ *
+ * These strings could be parsed and **normalized** to your canonical `TemporalUnitType`
+ * (e.g., `"seconds"` → `"s"`, `"us"` → `"μs"`, `"megayears"` → `"Myr"`).
+ *
+ * ## Scope & conventions
+ * - **Durations only** (not timestamps or "ago" semantics).
+ * - **Day** is the [SI](https://en.wikipedia.org/wiki/International_System_of_Units) day: exactly **86 400 s**.
+ * - **Year-family** (`yr`, `kyr`, `Myr`, `Gyr`) is based on the **Julian year**
+ *   (365.25 d = 31 557 600 s) for stable large-scale calculations.
+ * - **ASCII micro**: `"us"` is accepted and normalized to `"μs"`.
+ * - **Geology-style** tokens (`Ma`, `Ga`, `megaannum`, `gigaannum`) are accepted
+ *   but normalized to `Myr`/`Gyr` **as durations** (not "million years ago").
+ * - **Case-sensitive**: tokens are matched exactly as listed.
+ *
+ * ## Recommended flow
+ * 1) Accept `TemporalUnitAliasType` from users/IO.
+ * 2) Normalize to `TemporalUnitType`.
+ * 3) Use only canonical units for arithmetic, storage, and serialization.
+ *
+ * @see https://www.bipm.org/en/publications/si-brochure ([SI](https://en.wikipedia.org/wiki/International_System_of_Units) Brochure — second & day)
+ * @see https://en.wikipedia.org/wiki/Julian_year_(astronomy) (Julian year used for `yr`/`kyr`/`Myr`/`Gyr`)
+ * @see https://en.wikipedia.org/wiki/Year#SI_multiples (Usage of `ka`/`Ma`/`Ga` vs `kyr`/`Myr`/`Gyr`)
+ * @category Temporal
+ */
+export type TemporalUnitAliasType = 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds' | 'us' | 'minute' | 'minutes' | 'hour' | 'hours' | 'day' | 'days' | 'year' | 'years' | 'yr' | 'yrs' | 'kiloyear' | 'kiloyears' | 'kyr' | 'megayear' | 'megayears' | 'megaannum' | 'megaannums' | 'Myr' | 'Ma' | 'gigayear' | 'gigayears' | 'gigaannum' | 'gigaannums' | 'Gyr' | 'Ga';
+/**
+ * Typed container for a scalar **duration**, combining a numeric `value`
+ * (from {@link ValueInterface}) with a canonical {@link TemporalUnitType} `unit`.
+ *
+ * ## Conventions
+ * - **Durations only** (not timestamps or "ago" semantics).
+ * - `unit` must be a **canonical symbol** (e.g., `'s'`, `'min'`, `'h'`, `'d'`, `'yr'`, `'Myr'`).
+ *   If you accept user-friendly aliases (e.g., `"seconds"`, `"hours"`), normalize them **before** constructing this type.
+ * - Day is the **SI day** (86 400 s) and year-family uses the **Julian year** (365.25 d).
+ *
+ * $$
+ * \text{seconds} \;=\; \text{value} \times \mathrm{SECONDS\_PER}[\text{unit}]
+ * $$
+ *
+ *
+ * @see {@link TemporalUnitType}
+ * @category Temporal
+ */
+export interface TemporalInterface extends ValueInterface {
+    /** Canonical temporal unit symbol (case-sensitive). */
+    unit: TemporalUnitType;
+}
+/**
+ * Represents a **time step measurement** in simulation, restricted to days.
+ *
+ * @extends ValueInterface
+ * @property {'day'} unit - The unit is always **days**.
+ *
+ * @example
+ * ```ts
+ * const timeStep: TimeStepInterface = { value: 1, unit: 'day' };
+ * ```
+ * @category Temporal
+ */
+export interface TimeStepInterface extends ValueInterface {
+    unit: 'd';
+}
+//# sourceMappingURL=temporal.d.ts.map

package/dist/temporal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.d.ts","sourceRoot":"","sources":["../src/temporal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,gBAAgB,GAExB,GAAG,GACH,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GAEJ,KAAK,GACL,GAAG,GACH,GAAG,GAEH,IAAI,GACJ,KAAK,GACL,KAAK,GACL,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,qBAAqB,GAC7B,QAAQ,GACR,SAAS,GACT,aAAa,GACb,cAAc,GACd,aAAa,GACb,cAAc,GACd,IAAI,GACJ,QAAQ,GACR,SAAS,GACT,MAAM,GACN,OAAO,GACP,KAAK,GACL,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,KAAK,GACL,UAAU,GACV,WAAW,GACX,KAAK,GACL,UAAU,GACV,WAAW,GACX,WAAW,GACX,YAAY,GACZ,KAAK,GACL,IAAI,GACJ,UAAU,GACV,WAAW,GACX,WAAW,GACX,YAAY,GACZ,KAAK,GACL,IAAI,CAAC;AAET;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD,uDAAuD;IACvD,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD,IAAI,EAAE,GAAG,CAAC;CACX"}

package/dist/temporal.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=temporal.js.map

package/dist/temporal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.js","sourceRoot":"","sources":["../src/temporal.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@interstellar-tools/types",
+  "version": "0.1.1",
+  "description": "types",
+  "keywords": [
+    "types"
+  ],
+  "homepage": "https://phun-ky.net/projects/interstellar-tools",
+  "bugs": {
+    "url": "https://github.com/phun-ky/interstellar-tools/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phun-ky/interstellar-tools.git"
+  },
+  "funding": "https://github.com/phun-ky/interstellar-tools?sponsor=1",
+  "license": "MIT",
+  "author": "Alexander Vassbotn Røyne-Helgesen <alexander@phun-ky.net>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "release": "release-it",
+    "test": "tsx --test **/__tests__/**/*.spec.ts",
+    "pretest:ci": "rm -rf coverage && mkdir -p coverage",
+    "test:ci": "glob -c \"node --import tsx --test --no-warnings --experimental-test-coverage --test-reporter=cobertura --test-reporter-destination=coverage/cobertura-coverage.xml --test-reporter=spec --test-reporter-destination=stdout\" \"**/__tests__/**/*.spec.ts\""
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.3",
+    "eslint": "^9.27.0",
+    "eslint-config-phun-ky": "^1.0.3",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.9.0",
+    "npm": ">=11.5.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}