@elite-dangerous-almanac/core 0.1.0-beta.1

package/dist/ship-loadout-Ba63RDf-.d.ts

@@ -0,0 +1,1059 @@
+import { ModuleEngineering, LoadoutModule, LoadoutEvent, SlefHeader, Slef } from './ships/slef.js';
+import { FrameShiftDriveParams } from './ships/jump-range.js';
+import { BuildSlot, SlotKind } from './ships/slots.js';
+import { OutfittingModule } from './ships/modules.js';
+import { PowerBudget } from './ships/power.js';
+import { ShieldMetrics } from './ships/shields.js';
+import { ArmourMetrics } from './ships/armour.js';
+import { WeaponMetrics, WeaponTotals } from './ships/weapons.js';
+import { AmmunitionCapacity } from './ships/ammunition.js';
+import { PreEngineeredVariant } from './ships/pre-engineered.js';
+import { SourcePurchaseRecord } from './ships/source-purchase.js';
+import { CalculationResult, FuelCapacity } from './ships/loadout-calculations.js';
+import { LoadoutValidation } from './ships/loadout-validation.js';
+
+/**
+ * Immutable fitted-module snapshots returned by {@link ShipLoadout}.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * A point-in-time, deeply frozen view of the module fitted in one slot.
+ *
+ * The view is detached from its {@link ShipLoadout}: later edits do not change it, and
+ * mutating it throws. Fetch a new view with {@link ShipLoadout.fittedModuleAt} after an
+ * state-changing edit; reads made without an intervening state change reuse the same
+ * frozen snapshot. All mutations live on `ShipLoadout`, keyed by {@link slot}; this
+ * avoids the stale-handle lifecycle that a live proxy would otherwise need.
+ *
+ * @example
+ * ```ts
+ * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+ *
+ * declare const build: ShipLoadout;
+ *
+ * const before = build.fittedModuleAt('FrameShiftDrive')!;
+ * build.applyBlueprint(before.slot, 'FSD_LongRange', { grade: 5 });
+ * const after = build.fittedModuleAt(before.slot)!;
+ * before.engineering; // unchanged
+ * after.engineering;  // the applied blueprint
+ * ```
+ */
+interface FittedModule {
+    /** Slot key in the build's own spelling. */
+    readonly slot: string;
+    /** Frontier module symbol, e.g. `"Int_Hyperdrive_Size6_Class5"`. */
+    readonly symbol: string;
+    /** Whether the module was powered on, or `undefined` when unspecified. */
+    readonly on: boolean | undefined;
+    /** Zero-based power-priority group, or `undefined` when unspecified. */
+    readonly priority: number | undefined;
+    /** Module health in `[0, 1]`, or `undefined` when unspecified. */
+    readonly health: number | undefined;
+    /** Captured purchase value in credits, or `undefined` when unspecified. */
+    readonly value: number | undefined;
+    /** Applied engineering, or `undefined` for a stock module. */
+    readonly engineering: ModuleEngineering | undefined;
+    /** Detached, journal-shaped fitted record. */
+    readonly raw: LoadoutModule;
+    /** Snapshotted base module stats, or `null` when unresolved. */
+    readonly stats: OutfittingModule | null;
+    /**
+     * Post-engineering module stats, or `null` when unresolved. For weapons, journal
+     * damage per second is resolved back to per-round damage and falloff is capped at
+     * maximum range. Exact damage components follow the engineered total and disappear
+     * when a damage conversion replaces them with a fractional distribution.
+     */
+    readonly effectiveStats: OutfittingModule | null;
+    /** Fully rearmed ammunition capacity, or `null` for modules without ammunition. */
+    readonly ammunition: AmmunitionCapacity | null;
+    /** Identified fixed pre-engineered variant, or `null` when not uniquely identified. */
+    readonly preEngineeredVariant: PreEngineeredVariant | null;
+}
+
+/**
+ * Immutable slot snapshots returned by {@link ShipLoadout}.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * A point-in-time, deeply frozen view of one hull mount.
+ *
+ * The view is detached from its {@link ShipLoadout}; after an edit that changes the
+ * build, call {@link ShipLoadout.slots} again for the current view. Reads made without an
+ * intervening state change reuse the same frozen snapshots. Mutations and candidate
+ * filtering stay on `ShipLoadout` and take the slot `key`, leaving this value serializable
+ * and free of lifecycle rules.
+ *
+ * @example
+ * Walking a build's mounts. Slot keys come from the game and are not derivable from
+ * position, so read the slot's `key` rather than composing one.
+ *
+ * ```ts
+ * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+ * import type { LoadoutEvent } from '@elite-dangerous-almanac/core/ships/slef';
+ *
+ * declare const event: LoadoutEvent;
+ *
+ * // Figures below are one build's — a Federal Corvette.
+ * const build = ShipLoadout.fromLoadout(event);
+ *
+ * build.slots().length; // -> 38   every mount on the hull
+ * build.slots('hardpoint').length; // -> 7
+ *
+ * const first = build.slots('hardpoint')[0];
+ * first?.key; // -> 'HugeHardpoint1'      what ShipLoadout.setModule takes
+ * first?.name; // -> 'Huge Hardpoint 1'   what a UI shows
+ * first?.size; // -> 4
+ * first?.module?.symbol; // -> 'hpt_beamlaser_gimbal_huge'; undefined when the mount is empty
+ * ```
+ *
+ * @example
+ * The view is a snapshot, not a handle — re-read it after an edit.
+ *
+ * ```ts
+ * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+ * import { HARDPOINT_MODULES } from '@elite-dangerous-almanac/core/ships/modules-hardpoint';
+ * import { getModuleBySymbol } from '@elite-dangerous-almanac/core/ships/modules';
+ *
+ * const build = ShipLoadout.empty('Sidewinder');
+ * const before = build.slots('hardpoint')[0];
+ * before?.key; // -> 'SmallHardpoint1'
+ * before?.module; // -> null
+ *
+ * const pulse = getModuleBySymbol('Hpt_PulseLaser_Fixed_Small', HARDPOINT_MODULES);
+ * if (pulse) build.setModule('SmallHardpoint1', pulse);
+ *
+ * before?.module; // -> still null — `before` describes the build as it was
+ * build.slots('hardpoint')[0]?.module?.symbol; // -> 'Hpt_PulseLaser_Fixed_Small'
+ * ```
+ */
+type LoadoutSlot = BuildSlot & {
+    /** Human-readable label, e.g. `"Frame Shift Drive"`. */
+    readonly name: string;
+    /** Frozen fitted-module snapshot, or `null` when this mount is empty. */
+    readonly module: FittedModule | null;
+};
+
+/**
+ * {@link ShipLoadout} — a mutable fitted-ship model that both **answers questions**
+ * about a build and **edits** it.
+ *
+ * Load one from a SLEF export (or a journal `Loadout` event) to read back the ship's
+ * identity, mass and fuel and ask for jump range and per-jump fuel; or start an
+ * {@link ShipLoadout.empty | empty} hull, enumerate its {@link ShipLoadout.slots | slots},
+ * and {@link ShipLoadout.setModule | fit} and {@link ShipLoadout.removeModule | remove}
+ * modules. It composes the data-free pieces of this folder — the SLEF parser
+ * (`./slef`), the jump-range maths (`./jump-range`), the slot model (`./slots`), and
+ * the module and ship catalogues (each record carrying its own stats).
+ *
+ * Instances are **mutable**: `setModule`/`removeModule` change the build in place and
+ * return `this` for chaining. Values a SLEF export already computed (its
+ * `UnladenMass`, `FuelCapacity`, …) are trusted verbatim; for a build assembled from
+ * scratch those figures are computed from the fitted modules and the hull's stats.
+ * Editing an imported build adjusts the supplied aggregate figures by the changed
+ * module's contribution; when that contribution is unknown, the affected figure is
+ * discarded and recomputed rather than allowed to go stale.
+ * `setModule` snapshots the complete record it receives, including resolved
+ * pre-engineered or caller-supplied stats, so every later metric uses the article that
+ * was actually fitted rather than resolving its symbol back to a stock module.
+ * Slot and fitted-module queries return deeply frozen point-in-time values; edits are
+ * made only through this facade, then observed by querying again.
+ *
+ * **Slot keys are matched case-insensitively.** Frontier writes `FrameShiftDrive` and
+ * `LargeMiningHardpoint1`, but a SLEF producer may lower-case every key as the
+ * specification's own example does — Inara writes `frameshiftdrive` and
+ * `largemininghardpoint1` — and both spellings name the same mount, whether you are
+ * reading it or fitting into it. What a build already carries is never rewritten to
+ * match, so re-exporting an import returns the producer's own spelling untouched.
+ *
+ * @remarks
+ * This is the batteries-included ship facade: resolving arbitrary journal module
+ * ids and engineering recipes requires the complete ship/module, blueprint, and
+ * experimental-effect catalogues. Import `./slef`, `./jump-range`, or an individual
+ * module catalogue instead when you only need one data-free operation or one
+ * outfitting category.
+ *
+ * @example
+ * ```ts
+ * declare const slefJsonString: string;
+ *
+ * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+ *
+ * // Read a build:
+ * const build = ShipLoadout.fromSlef(slefJsonString);
+ * build.maxJumpRange();  // -> 89.41  (best single jump, one jump's fuel, no cargo)
+ *
+ * // Assemble one:
+ * import { getModuleBySymbol } from '@elite-dangerous-almanac/core/ships/modules';
+ * import { CORE_MODULES } from '@elite-dangerous-almanac/core/ships/modules-core';
+ * const conda = ShipLoadout.empty('Anaconda');
+ * conda.setModule('FrameShiftDrive', getModuleBySymbol('Int_Hyperdrive_Size6_Class5', CORE_MODULES)!);
+ * conda.slots('optional'); // every optional mount, occupied or empty, with size
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/** Optional mass overrides for a single calculation. */
+interface JumpOptions {
+    /** Fuel in the tank for the jump, in tonnes. Defaults to the full main tank. */
+    readonly fuel?: number;
+    /** Cargo aboard, in tonnes. Defaults to `0` (unladen). */
+    readonly cargo?: number;
+}
+/** Options for {@link ShipLoadout.applyBlueprint}. */
+interface ApplyBlueprintOptions {
+    /** The blueprint grade, `1`–`5`. */
+    readonly grade: number;
+    /**
+     * The engineering system's shared quality roll, `0`–`1`. Defaults to `1`
+     * (best roll). A legacy-engineered module's independently advanced attributes cannot be
+     * reconstructed from its single reported quality; import its stated modifiers instead.
+     */
+    readonly quality?: number;
+    /** The experimental (special) effect's Frontier `fdname`, if any. */
+    readonly experimental?: string;
+}
+/** Options for the defence figures a build reports. */
+interface DefenceOptions {
+    /**
+     * Pips to the systems capacitor, `0`–`4`, folded into the shield resistances.
+     * Defaults to `0` — the bare shield, as an outfitting screen shows it.
+     */
+    readonly systemsPips?: number;
+}
+/** One fitted weapon and what it does, as {@link ShipLoadout.weaponMetrics} reports it. */
+interface FittedWeaponMetrics {
+    /** The hardpoint's slot key, e.g. `"LargeHardpoint1"`. */
+    readonly slot: string;
+    /** The weapon's internal symbol. */
+    readonly symbol: string;
+    /** The weapon's display name, e.g. `"Multi-Cannon"`. */
+    readonly name: string;
+    /** Whether the weapon is switched on — a disabled weapon is excluded from the totals. */
+    readonly enabled: boolean;
+    /** What this weapon does per second, post-engineering. */
+    readonly metrics: WeaponMetrics;
+    /**
+     * How many rounds it holds when fully rearmed, post-engineering — `null` for a laser,
+     * which carries none. A capacity, not a rearm state: see {@link FittedModule.ammunition}.
+     */
+    readonly ammunition: AmmunitionCapacity | null;
+}
+/** A build's firepower: every fitted weapon, and the totals across the enabled ones. */
+interface BuildWeaponMetrics {
+    /** Every fitted weapon, in slot order. */
+    readonly weapons: readonly FittedWeaponMetrics[];
+    /** The additive totals across the **enabled** weapons. */
+    readonly total: WeaponTotals;
+}
+/** A build's jump ranges at the loads that matter, in light-years. */
+interface JumpRangeSummary {
+    /**
+     * Best single jump: no cargo, and only one jump's fuel aboard — the figure the game
+     * and EDSY label "maximum jump range".
+     */
+    readonly max: number;
+    /** Single jump on a full tank with an empty hold. */
+    readonly unladen: number;
+    /** Single jump on a full tank with a full hold. */
+    readonly laden: number;
+    /** Summed range of every jump on one full tank, empty hold. */
+    readonly totalUnladen: number;
+    /** Summed range of every jump on one full tank, full hold. */
+    readonly totalLaden: number;
+}
+/** A blueprint that can engineer a module, with the grades it offers. */
+interface AvailableBlueprint {
+    /** The blueprint's Frontier `fdname`, e.g. `"FSD_LongRange"`. */
+    readonly fdname: string;
+    /** The grades the blueprint offers, ascending (e.g. `[1, 2, 3, 4, 5]`). */
+    readonly grades: readonly number[];
+}
+/** How to shape a build on the way out — see {@link ShipLoadout.toLoadoutEvent}. */
+interface LoadoutExportOptions {
+    /**
+     * Module order. `'fitted'` — the default — keeps the order the build carries: an
+     * import's own `Modules[]` order, or the order modules were fitted. `'slots'`
+     * re-orders into outfitting-panel order; a module in a slot the hull's layout does
+     * not describe keeps its relative position at the end rather than being dropped.
+     */
+    readonly moduleOrder?: 'fitted' | 'slots';
+    /**
+     * Write `On: true` / `Priority: 0` on modules that carry neither — as a journal
+     * always does and a build assembled here never does. Off by default, following
+     * SLEF's "require what is necessary, do not force the rest".
+     */
+    readonly explicitPower?: boolean;
+    /**
+     * Which credits to quote. `'retail'` — the default — prices the build from the
+     * catalogue: the bare hull's `hullCost`, every fitted module's list price, and a
+     * `Rebuy` of 5% of the two.
+     *
+     * `'source'` quotes the build's {@link ShipLoadout.sourcePurchase | source purchase
+     * record} instead — `HullValue`, `ModulesValue`, `Rebuy` and the per-module `Value`
+     * figures exactly as the capture stated them, and nothing where it stated nothing.
+     * An unedited capture therefore re-exports its own credits unchanged.
+     *
+     * Each captured figure is pinned to what it was paid for, so an edit narrows the
+     * export rather than staling it. A slot whose module has been swapped is left
+     * unpriced, because the figure was paid for the article that *was* fitted; and
+     * `ModulesValue` and `Rebuy` are dropped once any priced module has been swapped or
+     * removed, since they then cover an article no longer aboard. Removing a module the
+     * capture listed but never priced is the one case this cannot detect: only the
+     * capture ever knew which unpriced modules its total counted.
+     *
+     * `HullValue` always stands: a captured hull figure names no slot, so no edit
+     * narrows it. Note that on a game capture it counts the hull *with* its stock
+     * fittings, and removing one of those leaves it overstating what is aboard.
+     *
+     * A build with no source record — one assembled here, or a capture that quoted no
+     * credits — exports no credit figure at all rather than falling back to retail.
+     */
+    readonly credits?: 'retail' | 'source';
+}
+/** As {@link LoadoutExportOptions}, plus the SLEF envelope — see {@link ShipLoadout.toSlef}. */
+interface SlefExportOptions extends LoadoutExportOptions {
+    /**
+     * The envelope header identifying the exporting application.
+     *
+     * SLEF attribution belongs to the application producing the export, not to this
+     * calculation library, so callers must provide it.
+     */
+    readonly header: SlefHeader;
+    /** Spaces per indent for {@link ShipLoadout.toSlefString}. `0` (the default) is compact. */
+    readonly indent?: number;
+}
+/**
+ * A fitted ship — read a SLEF export, or assemble a hull from scratch.
+ *
+ * @remarks
+ * Jump calculations resolve the frame shift drive's constants from the drive's module
+ * record, applying any engineering the build carries (a Long Range blueprint's
+ * `FSDOptimalMass`, for instance). For a SLEF build, mass comes from the export's
+ * `UnladenMass`; for an assembled build it is the hull mass plus every fitted module's
+ * mass (armour defaults to the zero-mass lightweight alloy).
+ *
+ * @example
+ * Read a build a player already flies, and ask it what an outfitting screen shows.
+ * Every figure below is one build's — a Krait Phantom explorer. Figures the capture
+ * already stated — `unladenMass` here — are trusted verbatim; the rest are computed
+ * from the fit.
+ *
+ * ```ts
+ * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+ * import type { LoadoutEvent } from '@elite-dangerous-almanac/core/ships/slef';
+ *
+ * // A `Loadout` line lifted from a player journal, parsed.
+ * declare const event: LoadoutEvent;
+ *
+ * const build = ShipLoadout.fromLoadout(event);
+ *
+ * build.shipSymbol; // -> 'krait_light'
+ * build.shipName; // -> 'Jenny Longuet'
+ * build.unladenMass; // -> 388.830017   (tonnes)
+ *
+ * build.maxJumpRange(); // -> 60.5478   (ly, best single jump)
+ * build.powerBudget().withinBudget; // -> true
+ * build.shieldMetrics()?.strength; // -> 743.12  (MJ)
+ * build.armourMetrics().hitPoints; // -> 307.8
+ * ```
+ *
+ * @example
+ * Assemble a hull instead. `empty` starts from the shipyard layout, `slots` enumerates
+ * the mounts, and `setModule` fits one — chainable, because the build is mutable.
+ *
+ * ```ts
+ * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+ * import { getModuleBySymbol } from '@elite-dangerous-almanac/core/ships/modules';
+ * import { CORE_MODULES } from '@elite-dangerous-almanac/core/ships/modules-core';
+ *
+ * const conda = ShipLoadout.empty('Anaconda');
+ * conda.slots().length; // -> 39   (every mount, occupied or not)
+ * conda.slots('optional').length; // -> 14
+ * conda.validation.complete; // -> false  (nothing fitted yet)
+ *
+ * const fsd = getModuleBySymbol('Int_Hyperdrive_Size6_Class5', CORE_MODULES);
+ * if (fsd) conda.setModule('FrameShiftDrive', fsd);
+ * ```
+ *
+ * @example
+ * Write a build back out. Retail credits are what the catalogue prices the fit at; pass
+ * `credits: 'source'` to export the figures a capture stated it paid instead — see
+ * {@link ShipLoadout.sourcePurchase}.
+ *
+ * ```ts
+ * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+ *
+ * declare const build: ShipLoadout;
+ *
+ * build.toLoadoutEvent(); // retail: hull cost plus every module's list price
+ * build.toLoadoutEvent({ credits: 'source' }); // the capture's own figures
+ * build.toSlefString({ header: { appName: 'MyApp', appVersion: '1.0.0' } });
+ * ```
+ */
+declare class ShipLoadout {
+    #private;
+    private constructor();
+    /**
+     * Build from a SLEF export.
+     *
+     * @param input - The SLEF JSON string, or an already-parsed SLEF object (see
+     * {@link parseSlef} for accepted shapes).
+     * @param index - Which entry to take when the export holds several builds.
+     * Defaults to the first.
+     * @returns The loadout for that entry.
+     * @throws {SyntaxError} If `input` is a string that is not valid JSON.
+     * @throws {TypeError} If the export holds no usable loadout, or `index` is out of
+     * range.
+     */
+    static fromSlef(input: unknown, index?: number): ShipLoadout;
+    /**
+     * Build from a bare journal `Loadout` event (the `data` half of a SLEF entry).
+     *
+     * @param event - A `Loadout` event object.
+     * @returns The loadout.
+     * @remarks
+     * Capture/instance state (`timestamp`, `ShipID`, `HullHealth`, `Hot`) and engineering
+     * provenance (`Engineer`, `EngineerID`, `BlueprintID`) are deliberately excluded
+     * from the durable build. See {@link LoadoutEvent} and {@link ModuleEngineering}.
+     * A pre-engineered/reward module is identified from its reported stat signature when
+     * the evidence uniquely matches a catalogue variant. Its complete fixed stat block is
+     * then used as the fitted record, including values the capture omits; a separately
+     * applied experimental effect is included when matching and remains authoritative in
+     * the captured modifiers. Under-specified or ambiguous evidence stays unidentified.
+     * An ordinary weapon recipe on a Guardian weapon identifies a final pre-engineered
+     * article; the import preserves that identity, uses the catalogue's complete hand-set
+     * stat block when the exact article is known, exposes no engineering options for it,
+     * and refuses attempts to engineer it further. Explicit journal modifiers remain
+     * authoritative over that stat block.
+     *
+     * The event's credit figures are kept twice over: as the live `hullValue` /
+     * `modulesValue` / `rebuy`, which an edit may invalidate, and as the immutable
+     * {@link sourcePurchase} record, which no edit touches.
+     *
+     * @throws {TypeError} If the event is not shaped like one. What is checked is the
+     * structure a build is assembled from, and the types of the fields naming things in
+     * it: `event` must be an object with an array of module objects in `Modules`; each
+     * module needs a string `Slot` and `Item`, and no two may claim the same slot; a
+     * module's `Engineering` must be an object, and that block's `Modifiers` an array of
+     * objects each carrying a string `Label`, whenever their key is there **at all**;
+     * and `event.Ship`, the block's `BlueprintName` and its `ExperimentalEffect` must be
+     * strings **when they carry a value**. Every remaining field — every number, every
+     * flag, a modifier's value beside its label — is trusted, so use
+     * {@link ShipLoadout.fromSlef} (or {@link parseSlef}) for input you did not produce,
+     * which reports all of them.
+     *
+     * A modifier's `Label` is required rather than checked-when-present because it is
+     * the only thing saying which stat moved: {@link fittedModuleAt} and the
+     * pre-engineered identification both read it unconditionally, so an entry without
+     * one would import cleanly and then break the build it produced.
+     *
+     * `Engineering` and its `Modifiers` are the fields where a `null` is not the same as
+     * an omission, because a relay writing `null` for a block or list it does not have
+     * would otherwise be read as one. An **absent** `Ship` *is* an omission, and not a
+     * failure: it is a hull nothing can name, which {@link validation} reports as
+     * `unknownHull`. Nor is a partial `Engineering` block — a capture may state
+     * modifiers without naming the recipe.
+     */
+    static fromLoadout(event: LoadoutEvent): ShipLoadout;
+    /**
+     * Start a new, empty build for a hull — no modules fitted.
+     *
+     * @param shipSymbol - The hull's internal symbol, e.g. `"Anaconda"`
+     * (case-insensitive).
+     * @returns An empty loadout whose {@link slots} come from the hull's declared
+     * layout.
+     * @throws {TypeError} If `shipSymbol` is not a string, or no hull with that symbol
+     * has a known slot layout.
+     * @example
+     * ```ts
+     * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * ShipLoadout.empty('Sidewinder').slots('hardpoint').length; // -> 2
+     * ```
+     */
+    static empty(shipSymbol: string): ShipLoadout;
+    /** The hull's internal id, e.g. `"explorer_nx"`. */
+    get shipSymbol(): string;
+    /** The player-given ship name, or `null` if the build has none. */
+    get shipName(): string | null;
+    /** The player-given ID plate, or `null` if the build has none. */
+    get shipIdent(): string | null;
+    /**
+     * Hull + modules mass with an empty tank and no cargo, in tonnes, or `null` if it
+     * cannot be determined (no `UnladenMass` in the export and either the hull or a
+     * fitted module has no known mass).
+     *
+     * @remarks
+     * A SLEF export's `UnladenMass` is trusted verbatim. Otherwise the mass is the
+     * hull's `hullMass` plus every fitted module's mass (post-engineering), with armour
+     * at the zero-mass lightweight default.
+     */
+    get unladenMass(): number | null;
+    /**
+     * Unladen mass with diagnostics for every missing input.
+     *
+     * @returns A complete imported or computed mass, otherwise `null` plus the hull or
+     * module fields that prevented the calculation.
+     */
+    get unladenMassResult(): CalculationResult<number>;
+    /**
+     * Fuel-tank capacities, in tonnes, or `null` when a tank or the hull's reserve
+     * capacity is unknown. A SLEF export's `FuelCapacity` is used when present;
+     * otherwise the main capacity is the sum of the fitted fuel tanks and the reserve
+     * comes from the hull's stats.
+     */
+    get fuelCapacity(): FuelCapacity | null;
+    /** Fuel capacity with diagnostics instead of unknown tanks collapsing to zero. */
+    get fuelCapacityResult(): CalculationResult<FuelCapacity>;
+    /**
+     * Cargo capacity, in tonnes, or `null` when a fitted optional module cannot be
+     * classified. A SLEF export's `CargoCapacity` is used when present; otherwise it is
+     * the sum of the fitted cargo racks.
+     */
+    get cargoCapacity(): number | null;
+    /** Cargo capacity with diagnostics instead of unknown racks collapsing to zero. */
+    get cargoCapacityResult(): CalculationResult<number>;
+    /**
+     * Hull cost in credits represented by the build, or `null` if unknown.
+     *
+     * @remarks
+     * This is the live figure, kept coherent with edits: an import's own `HullValue`
+     * until something invalidates it. For the capture's figure as captured — which no
+     * edit changes — read {@link sourcePurchase}.
+     */
+    get hullValue(): number | null;
+    /**
+     * Fitted-modules cost in credits represented by the build, or `null` if
+     * unknown — including after an edit discarded an import's figure, since no catalogue
+     * records what a replaced module was bought for. {@link sourcePurchase} keeps the
+     * captured figure regardless.
+     */
+    get modulesValue(): number | null;
+    /**
+     * Insurance rebuy cost in credits represented by the build, or `null` if
+     * unknown. Discarded by an edit for the same reason as {@link modulesValue}, and
+     * likewise preserved by {@link sourcePurchase}.
+     */
+    get rebuy(): number | null;
+    /**
+     * What the capture this build came from said was **paid** for it — a read-only
+     * {@link SourcePurchaseRecord}, or `null` for a build assembled here or imported
+     * from a capture that quoted no credits at all.
+     *
+     * @remarks
+     * The record is provenance about the source, so it is fixed at import and **survives
+     * every edit**: fit, remove or engineer whatever you like and it still reports the
+     * figures the capture carried, for the modules the capture carried them for. That is
+     * what {@link hullValue}, {@link modulesValue} and {@link rebuy} cannot do — they
+     * describe the build in hand, so an edit that invalidates one drops it.
+     *
+     * The two answer different questions and neither substitutes for the other. A
+     * captured price belongs to one commander's purchase history, discounts included;
+     * the library's own figures are catalogue retail. Export picks between them
+     * explicitly, and quotes retail unless asked otherwise — see
+     * {@link LoadoutExportOptions.credits}.
+     *
+     * @example
+     * ```ts
+     * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     * import { getSourceModuleValue } from '@elite-dangerous-almanac/core/ships/source-purchase';
+     *
+     * declare const slefJson: string;
+     *
+     * const build = ShipLoadout.fromSlef(slefJson);
+     * const paid = build.sourcePurchase!;
+     * paid.hullValue; // -> 189326510, as captured
+     * getSourceModuleValue(paid, 'powerplant')?.value; // -> what that plant cost its owner
+     *
+     * build.removeModule('Slot05_Size4');
+     * build.modulesValue;                 // -> null   unavailable after the edit
+     * paid.modulesValue;                  // -> 192625195, the captured figure
+     * ```
+     */
+    get sourcePurchase(): SourcePurchaseRecord | null;
+    /**
+     * Structural validity and operational completeness of this build.
+     *
+     * @remarks
+     * Optional, hardpoint and utility mounts may be empty. Armour and all seven core
+     * mounts must be filled for `complete` to be true. An unknown hull or module is
+     * incomplete; a module in a nonexistent or incompatible slot is invalid.
+     */
+    get validation(): LoadoutValidation;
+    /**
+     * Frozen point-in-time views of the hull's mounts in outfitting-panel order.
+     *
+     * @param kind - Optionally keep only one mount kind. Omit it for every mount.
+     * @returns Detached slot views. Repeated reads at the same build version reuse the
+     * same frozen array and records; every state-changing edit makes the next read produce
+     * new snapshots.
+     * @throws {TypeError} If the hull has no known slot layout.
+     * @example
+     * ```ts
+     * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * const emptyHardpoints = ShipLoadout.empty('Sidewinder').slots('hardpoint');
+     * emptyHardpoints.every((slot) => slot.module === null); // true
+     * ```
+     */
+    slots(kind?: SlotKind): readonly LoadoutSlot[];
+    /**
+     * A deeply frozen, point-in-time view of the module in a slot.
+     *
+     * @param slotKey - Slot key, matched case-insensitively.
+     * @returns A detached view, or `null` when the slot is empty or unknown. Repeated
+     * reads at the same build version reuse the same frozen record; every state-changing
+     * edit makes the next read produce a new snapshot.
+     * @throws {TypeError} If `slotKey` is not a string.
+     */
+    fittedModuleAt(slotKey: string): FittedModule | null;
+    /**
+     * Every fitted module as a deeply frozen point-in-time view.
+     *
+     * @returns Detached module snapshots in the order the build carries them. The array
+     * and every nested record are frozen; query again after an edit for current state.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * build.fittedModules().map((module) => `${module.slot}: ${module.symbol}`);
+     * ```
+     */
+    fittedModules(): readonly FittedModule[];
+    /**
+     * Return the computable blueprints offered to a fitted module.
+     *
+     * @param slotKey - Slot key, matched case-insensitively.
+     * @returns Frozen blueprint descriptors in engineering-menu order, or an empty
+     * array when the slot is empty, unresolved, final, or has no engineering menu.
+     * @throws {TypeError} If `slotKey` is not a string.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * build.availableBlueprints('FrameShiftDrive').map(({ fdname }) => fdname);
+     * ```
+     */
+    availableBlueprints(slotKey: string): readonly AvailableBlueprint[];
+    /**
+     * Return the computable experimental effects offered to a fitted module.
+     *
+     * @param slotKey - Slot key, matched case-insensitively.
+     * @returns Frozen Frontier effect ids in engineering-menu order, or an empty array
+     * when the slot is empty, unresolved, final, or has no experimental menu.
+     * @throws {TypeError} If `slotKey` is not a string.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * build.availableExperimentalEffects('FrameShiftDrive');
+     * // -> ['special_fsd_heavy', ...]
+     * ```
+     */
+    availableExperimentalEffects(slotKey: string): readonly string[];
+    /**
+     * The modules that fit a given slot — its size, kind and any restriction all
+     * satisfied.
+     *
+     * @param slotKey - The slot key to fit, matched case-insensitively (journal spelling).
+     * @returns The fitting modules, in complete-catalogue order.
+     * @throws {RangeError} If the hull has no slot with that key.
+     * @throws {TypeError} If `slotKey` is not a string, or the hull has no known slot
+     * layout (a SLEF build on an unrecognised hull).
+     * @example
+     * ```ts
+     * import { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * ShipLoadout.empty('Anaconda').modulesForSlot('FrameShiftDrive');
+     * ```
+     */
+    modulesForSlot(slotKey: string): OutfittingModule[];
+    /**
+     * Fit a module into a slot, replacing whatever is there.
+     *
+     * @param slotKey - The slot key to fit into, matched case-insensitively (journal
+     * spelling). An occupied slot keeps the key the build already spells it with, so
+     * fitting into an import never renames one of its mounts.
+     * @param module - The module to fit (resolve it from a catalogue first, e.g. with
+     * {@link getModuleBySymbol}). The complete record is snapshotted, so a result from
+     * `getPreEngineeredStats` or a caller-supplied catalogue keeps its resolved stats.
+     * @returns `this`, for chaining.
+     * @throws {RangeError} If the hull has no slot with that key.
+     * @throws {TypeError} If `slotKey` is not a string; `module` is null/undefined (e.g. a
+     * `getModuleBySymbol` miss) or is not an outfitting module at all; the module does not
+     * fit the slot (wrong kind, too large, or a restriction the module does not satisfy);
+     * or the hull has no known slot layout (a SLEF build on an unrecognised hull).
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * import { getModuleBySymbol } from '@elite-dangerous-almanac/core/ships/modules';
+     * import { CORE_MODULES } from '@elite-dangerous-almanac/core/ships/modules-core';
+     * const fsd = getModuleBySymbol('Int_Hyperdrive_Size6_Class5', CORE_MODULES)!;
+     * const tank = getModuleBySymbol('Int_FuelTank_Size6_Class3', CORE_MODULES)!;
+     * build.setModule('FrameShiftDrive', fsd).setModule('Slot01_Size7', tank);
+     * ```
+     */
+    setModule(slotKey: string, module: OutfittingModule): this;
+    /**
+     * Empty a slot.
+     *
+     * @param slotKey - The slot key to clear, matched case-insensitively (journal
+     * spelling).
+     * @returns `this`, for chaining. Clearing an already-empty slot is a no-op.
+     * @throws {TypeError} If `slotKey` is not a string, or names the built-in cargo
+     * hatch, which cannot be removed or replaced.
+     */
+    removeModule(slotKey: string): this;
+    /**
+     * Engineer the module in a slot — apply a blueprint (with a grade and quality) and
+     * an optional experimental effect, computing the resulting stat modifiers.
+     *
+     * The modifiers are stored as an `Engineering` block on the fitted module, so the
+     * build's jump-range and mass calculations pick them up automatically. The block keeps
+     * the `BlueprintName` you passed, so it reads back the way the build declared it.
+     *
+     * **Which recipe an id names can depend on the module.** The game writes
+     * `Sensor_LongRange` and `Sensor_WideAngle` for both a sensor suite's modification and a
+     * utility scanner's, and the two roll different stats in opposite directions — Long
+     * Range costs the suite mass and the scanner power draw. So the id is resolved against
+     * the module's menu before anything is computed, and a wake scanner engineered
+     * `Sensor_LongRange` gets the scanner's numbers, which `BLUEPRINTS` keys
+     * `Scanner_LongRange`. Reading a stored block back the same way means resolving it the
+     * same way: `resolveBlueprintForModule` in `ships/blueprint-journal` is that lookup.
+     *
+     * @param slotKey - The slot whose module to engineer, matched case-insensitively
+     * (journal spelling).
+     * @param fdname - The blueprint recipe's Frontier `fdname`, e.g. `"FSD_LongRange"`.
+     * @param options - {@link ApplyBlueprintOptions}: `grade` (1–5), optional `quality`
+     * (0–1, default 1), and optional `experimental` effect `fdname`. A nullish
+     * `experimental` means no effect, the same as leaving it out. Each is read once,
+     * before anything is checked, so an accessor cannot answer the check and the use
+     * differently.
+     * @returns `this`, for chaining.
+     * @throws {RangeError} If the slot is empty, or the blueprint/grade/experimental is
+     * unknown, or `quality` is outside `[0, 1]`.
+     * @throws {TypeError} If `slotKey` or `fdname` is not a string, `options` is not an
+     * object, or `options.experimental` carries a value that is not a string — a nullish
+     * one is no effect, not a wrong type; the fitted module has no stats to engineer; or the id names a
+     * decorative modification, which names no recipe (see
+     * {@link DECORATIVE_MODIFICATIONS}); or the module is not offered the blueprint — by
+     * its engineering menu, by the journal spelling of an entry on that menu, by the
+     * generic spelling of a recipe that menu lists under a family's name, or by being sold
+     * already carrying it; the fitted article is final and accepts no further engineering;
+     * or the module is not offered the experimental effect, which its
+     * menu alone decides; or the catalogue does not carry every base stat the recipe
+     * modifies. Incomplete engineering is rejected rather than stored as a partial journal
+     * modifier block.
+     * @example
+     * ```ts
+     * import { getModuleBySymbol } from '@elite-dangerous-almanac/core/ships/modules';
+     * import { CORE_MODULES } from '@elite-dangerous-almanac/core/ships/modules-core';
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * const fsd = getModuleBySymbol('Int_Hyperdrive_Size6_Class5', CORE_MODULES)!;
+     *
+     * build.setModule('FrameShiftDrive', fsd)
+     *      .applyBlueprint('FrameShiftDrive', 'FSD_LongRange', {
+     *          grade: 5,
+     *          experimental: 'special_fsd_heavy',
+     *      });
+     * build.maxJumpRange(); // uses the engineered optimal mass
+     * ```
+     */
+    applyBlueprint(slotKey: string, fdname: string, options: ApplyBlueprintOptions): this;
+    /**
+     * Strip the engineering from a slot's module, restoring its base stats.
+     *
+     * @param slotKey - The slot to de-engineer, matched case-insensitively (journal
+     * spelling).
+     * @returns `this`, for chaining. A no-op if the slot is empty or un-engineered.
+     * @throws {TypeError} If `slotKey` is not a string, or the fitted article is final
+     * pre-engineered and its baked engineering cannot be removed.
+     */
+    clearEngineering(slotKey: string): this;
+    /**
+     * Switch a fitted module on or off.
+     *
+     * @param slotKey - The slot's journal key, e.g. `"PowerPlant"`, matched
+     * case-insensitively.
+     * @param on - `true` to power it, `false` to switch it off.
+     * @returns `this`, for chaining.
+     * @throws {RangeError} If the slot is empty.
+     * @throws {TypeError} If `slotKey` is not a string.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * build.setModuleEnabled('TinyHardpoint6', false); // an unpowered heat sink
+     * ```
+     */
+    setModuleEnabled(slotKey: string, on: boolean): this;
+    /**
+     * Set a fitted module's power-priority group.
+     *
+     * @param slotKey - The slot's journal key, matched case-insensitively.
+     * @param priority - The journal's **zero-based** group, `0`–`4`. Note that the
+     * outfitting panel — and {@link powerBudget}'s `bands[].priority` — number the same
+     * five groups `1`–`5`.
+     * @returns `this`, for chaining.
+     * @throws {RangeError} If the slot is empty, or `priority` is not an integer in `[0, 4]`.
+     * @throws {TypeError} If `slotKey` is not a string.
+     */
+    setModulePriority(slotKey: string, priority: number): this;
+    /**
+     * This build as a journal `Loadout` event — the `data` half of a SLEF entry.
+     *
+     * @param options - Module ordering and how sparse to be about power state.
+     * @returns A fresh event. Every top-level figure is **recomputed** from the hull and
+     * the fitted modules rather than echoed from whatever an import supplied — the one
+     * exception being the credits, when `credits: 'source'` asks for the capture's own.
+     * Any figure that cannot be worked out is **left out** rather than emitted as a stale
+     * or zero value — SLEF requires nothing beyond `Ship` and `Modules`.
+     *
+     * Credits are quoted at **retail** by default: the bare hull's `hullCost` plus every
+     * fitted module's catalogue list price, with `Rebuy` 5% of the two. A source's own
+     * `HullValue` / `ModulesValue` / `Value` figures are deliberately not quoted here,
+     * because they record one commander's purchase history — the Deep Black's modules
+     * are all 12.25% off list — and purchase discounts are not a property of the build.
+     * They are not lost either: pass `credits: 'source'` to export the
+     * {@link sourcePurchase} record instead, as provenance rather than as a price.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * const event = build.toLoadoutEvent();
+     * event.MaxJumpRange; // recomputed, not the exporter's claim
+     * event.HullValue;    // the catalogue's list price
+     *
+     * build.toLoadoutEvent({ credits: 'source' }).HullValue; // what the capture paid
+     * ```
+     */
+    toLoadoutEvent(options?: LoadoutExportOptions): LoadoutEvent;
+    /**
+     * This build as a one-entry SLEF export.
+     *
+     * @param options - Ordering, power state, and the envelope header.
+     * @returns The export. Several builds travel together as
+     * `toSlef([a.toLoadoutEvent(), b.toLoadoutEvent()])` using the function of the same
+     * name from `./slef`.
+     */
+    toSlef(options: SlefExportOptions): Slef;
+    /**
+     * This build as SLEF JSON — ready to write to a file or put on the clipboard.
+     *
+     * @param options - As {@link toSlef}, plus `indent` (compact by default).
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * build.toSlefString({ header: { appName: 'MyApp', appVersion: '1.0.0' } });
+     * ```
+     */
+    toSlefString(options: SlefExportOptions): string;
+    /**
+     * The resolved frame-shift-drive constants for this build — post-engineering,
+     * with any Guardian FSD Booster folded into `jumpBoost`.
+     *
+     * @throws {TypeError} If the build has no frame shift drive, or its required jump
+     * constants are missing from the stats catalogue.
+     */
+    get frameShiftDrive(): FrameShiftDriveParams;
+    /**
+     * Best single-jump range, in light-years — no cargo, and exactly one jump's fuel
+     * aboard (the lightest the ship jumps). This is the figure the game and EDSY label
+     * "maximum jump range".
+     *
+     * @remarks
+     * Returns `0` when no fuel is available — an assembled build with no fuel tank
+     * fitted has an empty main tank, so there is nothing to jump on.
+     * @returns The best single jump, in light-years.
+     * @throws {TypeError} If the build has no usable frame shift drive, or its mass or
+     * fuel capacity cannot be determined.
+     */
+    maxJumpRange(): number;
+    /**
+     * The range of a single jump for a chosen fuel and cargo load, in light-years.
+     *
+     * @param options - {@link JumpOptions}. `fuel` defaults to a full main tank,
+     * `cargo` to `0`.
+     * @returns The jump's range, in light-years.
+     * @throws {TypeError} If the build has no usable frame shift drive or its mass
+     * cannot be determined; also if fuel capacity is unknown and `options.fuel` is
+     * omitted.
+     */
+    jumpRange(options?: JumpOptions): number;
+    /**
+     * Single-jump range on a full tank with a full cargo hold, in light-years.
+     *
+     * @returns The jump's range, in light-years.
+     * @throws {TypeError} If the build has no usable frame shift drive, or its mass,
+     * fuel capacity or cargo capacity cannot be determined.
+     */
+    ladenJumpRange(): number;
+    /**
+     * The fuel a single jump of a given distance costs, in tonnes.
+     *
+     * @param distance - The jump distance, in light-years.
+     * @param options - {@link JumpOptions}. `fuel` defaults to a full main tank,
+     * `cargo` to `0`.
+     * @returns Fuel used, in tonnes (capped at the drive's max fuel per jump).
+     * @throws {TypeError} If the build has no usable frame shift drive or its mass
+     * cannot be determined; also if fuel capacity is unknown and `options.fuel` is
+     * omitted.
+     */
+    fuelPerJump(distance: number, options?: JumpOptions): number;
+    /**
+     * Total multi-jump range on a full main tank, in light-years — the sum of
+     * successive jumps as the tank drains.
+     *
+     * @param options - `cargo` aboard, in tonnes; defaults to `0`.
+     * @returns The summed range of every jump on one full tank, in light-years.
+     * @throws {TypeError} If the build has no usable frame shift drive, or its mass or
+     * fuel capacity cannot be determined.
+     */
+    totalRange(options?: {
+        readonly cargo?: number;
+    }): number;
+    /**
+     * Every jump figure at once — best, unladen, laden, and the multi-jump totals.
+     *
+     * @returns The {@link JumpRangeSummary}, in light-years. For a partial load, call
+     * {@link jumpRange} with the `fuel` and `cargo` you actually have.
+     * @throws {TypeError} If the build has no usable frame shift drive, or its mass,
+     * fuel capacity or cargo capacity cannot be determined.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * const jumps = build.jumpRangeSummary();
+     * jumps.max;    // -> 89.41  (one jump's fuel, empty hold)
+     * jumps.laden;  // -> the range with the hold full
+     * // Half a tank and 32 t aboard, once the tank is known:
+     * const fuel = build.fuelCapacityResult;
+     * if (fuel.complete) build.jumpRange({ fuel: fuel.value.main / 2, cargo: 32 });
+     * ```
+     */
+    jumpRangeSummary(): JumpRangeSummary;
+    /**
+     * The build's power budget: what the plant makes, what the modules draw with
+     * hardpoints retracted and deployed, and which priority groups stay lit.
+     *
+     * Draws are post-engineering, modules switched off in the journal are skipped, and
+     * weapons (plus the utility fittings that are not always powered) count only
+     * towards the deployed total.
+     *
+     * @returns The {@link PowerBudget}. With no power plant fitted, `available` is `0`
+     * and nothing is powered. A fitted module whose draw the catalogue cannot supply is
+     * named in {@link PowerBudget.unknownDraws} rather than counted as drawing nothing,
+     * which makes every total a lower bound while that list is non-empty.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * const power = build.powerBudget();
+     * power.available;                  // -> 20.4 MW generated
+     * power.deployed;                   // -> 19.02 MW drawn, hardpoints out
+     * power.withinBudget;               // -> true
+     * power.bands[4]?.poweredDeployed;  // -> is priority group 5 still lit?
+     * ```
+     */
+    powerBudget(): PowerBudget;
+    /**
+     * The build's shields: strength in megajoules, where it comes from, and the
+     * effective resistances.
+     *
+     * Shield strength scales with the **hull's** mass, not the build's, so fitting
+     * more modules never weakens it. Boosters, Guardian shield reinforcement and any
+     * engineering are all folded in; switched-off modules are ignored.
+     *
+     * @param options - {@link DefenceOptions}. `systemsPips` (0–4) folds the SYS
+     * capacitor's own resistance into the reported figures; it defaults to `0`, which
+     * is what an outfitting screen shows.
+     * @returns The {@link ShieldMetrics}, or `null` when the build has no shield
+     * generator fitted (or has one switched off).
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * const shields = build.shieldMetrics();
+     * shields?.strength;              // -> MJ
+     * shields?.resistances.thermal;   // -> negative on a stock generator
+     * build.shieldMetrics({ systemsPips: 4 })?.resistances.thermal; // -> with 4 pips to SYS
+     * ```
+     */
+    shieldMetrics(options?: DefenceOptions): ShieldMetrics | null;
+    /**
+     * The build's armour: hull hit points, the bulkhead and reinforcement each
+     * contribute, and the effective resistances.
+     *
+     * @returns The {@link ArmourMetrics}. A build with no armour module fitted is
+     * reported on the stock lightweight alloy the hull leaves the shipyard with, which
+     * is what the game does.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * const hull = build.armourMetrics();
+     * hull.hitPoints;                  // -> total hull points
+     * hull.resistances.explosive;      // -> lightweight alloy is explosively weak
+     * hull.effectiveHitPoints.thermal; // -> thermal damage the hull can soak
+     * ```
+     */
+    armourMetrics(): ArmourMetrics;
+    /**
+     * The build's firepower: DPS, sustained DPS, weapons-capacitor draw, heat and power
+     * draw for every fitted weapon, plus the totals.
+     *
+     * Every figure is post-engineering. A weapon switched off in the journal is still
+     * listed — with its own metrics — but left out of the totals.
+     *
+     * @returns The {@link BuildWeaponMetrics}.
+     * @example
+     * ```ts
+     * import type { ShipLoadout } from '@elite-dangerous-almanac/core/ships/ship-loadout';
+     *
+     * declare const build: ShipLoadout;
+     *
+     * const guns = build.weaponMetrics();
+     * guns.total.damagePerSecond;          // -> burst DPS across the hardpoints
+     * guns.total.sustainedDamagePerSecond; // -> with reloads folded in
+     * guns.total.energyPerSecond;          // -> MW asked of the WEP capacitor
+     * guns.total.powerDraw;                // -> MW asked of the power plant when deployed
+     * guns.weapons[0]?.metrics.damageByType.thermal;
+     * guns.weapons[0]?.ammunition?.total;  // -> rounds aboard when fully rearmed
+     * ```
+     */
+    weaponMetrics(): BuildWeaponMetrics;
+}
+
+export { type ApplyBlueprintOptions as A, type BuildWeaponMetrics as B, type DefenceOptions as D, type FittedModule as F, type JumpOptions as J, type LoadoutExportOptions as L, ShipLoadout as S, type AvailableBlueprint as a, type FittedWeaponMetrics as b, type JumpRangeSummary as c, type LoadoutSlot as d, type SlefExportOptions as e };