@ksp-gonogo/sitrep-sdk 0.0.1 → 0.2.0-rc.12

package/dist/__generated__/contract.js

@@ -1,143 +1,1295 @@
 //     This code was generated by a Reinforced.Typings tool.
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
+/**
+* The game's save mode, from KSP's `Game.Modes`. It decides which career
+* surfaces (funds, tech tree, contracts, strategies, facility upgrades) mean
+* anything. `CareerStatus` is `null` outside career, so the mode is its own
+* Topic, `career.mode`, emitted in every mode.
+*
+* On the wire an enum is its integer ordinal: `Sandbox` 0, `Career` 1,
+* `Science` 2, `Unknown` 3.
+*
+* @category Career
+*/
 export var GameMode;
 (function (GameMode) {
+    /** A sandbox save (`SANDBOX`): no funds, science or reputation. */
     GameMode[GameMode["Sandbox"] = 0] = "Sandbox";
+    /**
+    * A career save (`CAREER`): funds, contracts, reputation and the tech tree all
+    * apply.
+    */
     GameMode[GameMode["Career"] = 1] = "Career";
+    /**
+    * A science save (`SCIENCE_SANDBOX`): the tech tree and science apply, funds
+    * and contracts do not.
+    */
     GameMode[GameMode["Science"] = 2] = "Science";
+    /**
+    * Any other KSP mode (a scenario or a mission), which has no player-career
+    * surface.
+    */
     GameMode[GameMode["Unknown"] = 3] = "Unknown";
 })(GameMode || (GameMode = {}));
-export var CommandErrorCode;
-(function (CommandErrorCode) {
-    CommandErrorCode[CommandErrorCode["None"] = 0] = "None";
-    CommandErrorCode[CommandErrorCode["Unknown"] = 1] = "Unknown";
-    CommandErrorCode[CommandErrorCode["NoVessel"] = 2] = "NoVessel";
-    CommandErrorCode[CommandErrorCode["ModeUnavailable"] = 3] = "ModeUnavailable";
-    CommandErrorCode[CommandErrorCode["Range"] = 4] = "Range";
-    CommandErrorCode[CommandErrorCode["NotFound"] = 5] = "NotFound";
-    CommandErrorCode[CommandErrorCode["Timeout"] = 6] = "Timeout";
-})(CommandErrorCode || (CommandErrorCode = {}));
+/**
+* Which kind of unlock a `MissingUnlock` names.
+*
+* @category System diagnostics
+*/
+export var UnlockKind;
+(function (UnlockKind) {
+    /** A tech node in the save's research tree. */
+    UnlockKind[UnlockKind["Tech"] = 0] = "Tech";
+    /** A space centre building's level. */
+    UnlockKind[UnlockKind["Facility"] = 1] = "Facility";
+})(UnlockKind || (UnlockKind = {}));
+/**
+* The degree of control a vessel currently has, the `controlSource` axis of
+* `CommsConnectivity`. The game's control level collapsed to three tiers:
+* partial covers both crewed and uncrewed partial control, and whether a crew
+* is aboard shows on `CommsConnectivity.hasLocalControl` instead.
+*
+* @category Comms
+*/
 export var CommsControlSource;
 (function (CommsControlSource) {
+    /**
+    * The craft has no control source. A reading, unlike
+    * `CommsControlSource.Unknown`.
+    */
     CommsControlSource[CommsControlSource["None"] = 0] = "None";
+    /**
+    * Partial control, crewed or uncrewed: stock's `PARTIAL_MANNED` or
+    * `PARTIAL_UNMANNED` level.
+    */
     CommsControlSource[CommsControlSource["Partial"] = 1] = "Partial";
+    /** Full control. */
     CommsControlSource[CommsControlSource["Full"] = 2] = "Full";
+    /**
+    * The game reported a control level this build does not name. Not
+    * `CommsControlSource.None`: the craft may well have control, but its level
+    * has no tier here. `CommsConnectivity.hasLocalControl` is false alongside it
+    * and says nothing.
+    */
+    CommsControlSource[CommsControlSource["Unknown"] = 3] = "Unknown";
 })(CommsControlSource || (CommsControlSource = {}));
+/**
+* What the active vessel can be commanded to do, for `CommsControl`. The
+* game's control level collapsed to three tiers, crewed and uncrewed partial
+* control sharing one.
+*
+* @category Comms
+*/
 export var CommsControlStateKind;
 (function (CommsControlStateKind) {
+    /**
+    * The craft cannot be commanded. A reading, unlike
+    * `CommsControlStateKind.Unknown`.
+    */
     CommsControlStateKind[CommsControlStateKind["None"] = 0] = "None";
+    /**
+    * Partial control, crewed or uncrewed: stock's `PARTIAL_MANNED` or
+    * `PARTIAL_UNMANNED` level.
+    */
     CommsControlStateKind[CommsControlStateKind["PartialManoeuvre"] = 1] = "PartialManoeuvre";
+    /** Full control. */
     CommsControlStateKind[CommsControlStateKind["Full"] = 2] = "Full";
+    /**
+    * The game reported a control level this build does not name, so whether the
+    * craft can be commanded is not known. Not `CommsControlStateKind.None`.
+    */
+    CommsControlStateKind[CommsControlStateKind["Unknown"] = 3] = "Unknown";
 })(CommsControlStateKind || (CommsControlStateKind = {}));
+/**
+* Whether a comms node is a ground station, or whether a hop touches one.
+* Carried by `CommsHop.kind` and `CommsNetworkNode.kind`.
+*
+* @category Comms
+*/
 export var CommsHopKind;
 (function (CommsHopKind) {
+    /** A ground station, or a hop with a ground station at either end. */
     CommsHopKind[CommsHopKind["Home"] = 0] = "Home";
+    /** A vessel node (the active craft included), or a hop between two vessels. */
     CommsHopKind[CommsHopKind["Relay"] = 1] = "Relay";
+    /**
+    * Not reported by the shipped backends: vessel nodes, the active craft
+    * included, arrive as `CommsHopKind.Relay`.
+    */
     CommsHopKind[CommsHopKind["Vessel"] = 2] = "Vessel";
 })(CommsHopKind || (CommsHopKind = {}));
+/**
+* Why `CommsDelay.oneWaySeconds` has the value it has.
+*
+* @category Comms
+*/
 export var CommsDelaySource;
 (function (CommsDelaySource) {
+    /**
+    * No delay measured: either there is no measurable path (the value is null) or
+    * delay is switched off (the value is 0).
+    */
     CommsDelaySource[CommsDelaySource["None"] = 0] = "None";
+    /** A light-time computed over the route's hop geometry. */
     CommsDelaySource[CommsDelaySource["SignalDelay"] = 1] = "SignalDelay";
+    /**
+    * Zero, because this save models no comms network at all: the stock CommNet
+    * difficulty option is off, so there are no ground stations, no relay graph
+    * and no path to measure a light-time over. Control reaches a craft directly,
+    * from anywhere, instantly.
+    *
+    * Not the same as a null `CommsDelay.oneWaySeconds`, which means there is a
+    * comms model and it can measure nothing right now: a blackout. A save with no
+    * comms model reports this alongside `connected:true`, and its channels keep
+    * arriving with nothing held back; a blackout reports null and they stop.
+    */
+    CommsDelaySource[CommsDelaySource["NoCommsModel"] = 2] = "NoCommsModel";
 })(CommsDelaySource || (CommsDelaySource = {}));
+/**
+* What one journey report says happened to a command, or to a cancel.
+*
+* @category Comms
+*/
+export var JourneyEventKind;
+(function (JourneyEventKind) {
+    /**
+    * A node is holding the command for its next window;
+    * `CommsJourneyEvent.untilUt` is when it predicts the command will leave. A
+    * node also reports this when a command it sent went unanswered and is its to
+    * send again.
+    */
+    JourneyEventKind[JourneyEventKind["Held"] = 0] = "Held";
+    /**
+    * A node that had held the command sent it on; `CommsJourneyEvent.untilUt` is
+    * when that node expects the light to land at its next node.
+    */
+    JourneyEventKind[JourneyEventKind["Departed"] = 1] = "Departed";
+    /** The command reached its expiry where it was and was deleted there. */
+    JourneyEventKind[JourneyEventKind["Expired"] = 2] = "Expired";
+    /** A cancel stopped the command at the node reporting. */
+    JourneyEventKind[JourneyEventKind["Cancelled"] = 3] = "Cancelled";
+    /**
+    * The command reached the craft and waits for earlier lane numbers, named in
+    * `CommsJourneyEvent.missing`.
+    */
+    JourneyEventKind[JourneyEventKind["Waiting"] = 4] = "Waiting";
+    /**
+    * The craft discarded the command because its lane number had already settled;
+    * `CommsJourneyEvent.detail` says how.
+    */
+    JourneyEventKind[JourneyEventKind["Discarded"] = 5] = "Discarded";
+    /**
+    * A cancel reached the craft before the command; the craft refuses the command
+    * whenever it arrives.
+    */
+    JourneyEventKind[JourneyEventKind["CancelStored"] = 6] = "CancelStored";
+    /**
+    * A cancel reached the craft after the command ran;
+    * `CommsJourneyEvent.untilUt` is when it ran.
+    */
+    JourneyEventKind[JourneyEventKind["CancelLate"] = 7] = "CancelLate";
+    /** A cancel reached a node after the command left it, and follows it on. */
+    JourneyEventKind[JourneyEventKind["CancelLateHere"] = 8] = "CancelLateHere";
+    /** The command ran at the craft; its result travels on the command's own reply. */
+    JourneyEventKind[JourneyEventKind["Ran"] = 9] = "Ran";
+})(JourneyEventKind || (JourneyEventKind = {}));
+/**
+* What a kerbal's place on the books is, as the dashboard means it: this
+* contract's own vocabulary, not a mirror of any game enum.
+*
+* The roster-status members line up with `KspRosterStatus` in meaning but not
+* in numbering, so never cast one to the other. `CrewStanding.Applicant` is a
+* standing KSP expresses as a KerbalType rather than a RosterStatus, and it
+* sits in one enumeration with the rest so "what is this kerbal's standing" is
+* one value.
+*
+* Behind `spaceCenter.crewRoster[].standing`, and it is the field to branch
+* on; see `CrewRosterEntry.situationOrdinal` for what the raw KSP ordinal
+* beside it is still good for.
+*
+* **Order.** The numbering is the reading order: sorted by value, a crew list
+* reads free to fly, then committed, then off the books. The SDK's
+* `CREW_STANDING_ORDER` is derived from it. A new member is inserted at its
+* place in that order rather than appended.
+*
+* @category Crew
+*/
+export var CrewStanding;
+(function (CrewStanding) {
+    /**
+    * No backend could say. Distinct from every member below, and never a stand-in
+    * for one: a capture that read no roster status at all reports this rather
+    * than guessing at Available.
+    */
+    CrewStanding[CrewStanding["Unknown"] = 0] = "Unknown";
+    /** A hireable candidate, not yet on the books. */
+    CrewStanding[CrewStanding["Applicant"] = 1] = "Applicant";
+    /** On the books and free to fly. */
+    CrewStanding[CrewStanding["Available"] = 2] = "Available";
+    /** On the books and currently crewing a vessel. */
+    CrewStanding[CrewStanding["Assigned"] = 3] = "Assigned";
+    /**
+    * On the books, standing down after a flight, and not assignable until the
+    * rest period ends. CrewStandingReading.StandingEndsAtUt carries its end.
+    *
+    * Derived from KSP's own `ProtoCrewMember.inactive`, so the stock backend
+    * reports it and every install gets it.
+    */
+    CrewStanding[CrewStanding["Resting"] = 4] = "Resting";
+    /** Killed: KSP's own `Dead` roster status. */
+    CrewStanding[CrewStanding["Dead"] = 5] = "Dead";
+    /**
+    * Missing: KSP's own `Missing` roster status, kept separate from
+    * `CrewStanding.Dead`.
+    */
+    CrewStanding[CrewStanding["Missing"] = 6] = "Missing";
+})(CrewStanding || (CrewStanding = {}));
+/**
+* Why a flight ended, carried on `FlightEnded`. The detail of a crash or a
+* recovery is on the `crash.lastCrash` and `recovery.lastSummary` channels;
+* this is only the coarse reason.
+*
+* @category Flights
+*/
+export var FlightEndReason;
+(function (FlightEndReason) {
+    /** The vessel was recovered. */
+    FlightEndReason[FlightEndReason["Recovered"] = 0] = "Recovered";
+    /** The vessel was lost to a collision or a hard splashdown. */
+    FlightEndReason[FlightEndReason["Crashed"] = 1] = "Crashed";
+    /**
+    * The game rewound (a revert or a quickload) to before the flight's end, or
+    * the flight was still open when the rewind happened. Also sent for a flight
+    * that had already ended by crash or recovery on the timeline the rewind
+    * discarded.
+    */
+    FlightEndReason[FlightEndReason["Reverted"] = 2] = "Reverted";
+    /**
+    * The vessel was destroyed without a collision, for example burning up on
+    * re-entry.
+    */
+    FlightEndReason[FlightEndReason["Destroyed"] = 3] = "Destroyed";
+})(FlightEndReason || (FlightEndReason = {}));
+/**
+* KSP's `ProtoCrewMember.RosterStatus`: a kerbal's standing in the roster.
+* Behind `spaceCenter.crewRoster[].situationOrdinal`, beside the name in
+* `CrewRosterEntry.situation`.
+*
+* @category Crew
+*/
+export var KspRosterStatus;
+(function (KspRosterStatus) {
+    /** In the roster and free to be assigned to a flight. */
+    KspRosterStatus[KspRosterStatus["Available"] = 0] = "Available";
+    /** Assigned to a vessel. */
+    KspRosterStatus[KspRosterStatus["Assigned"] = 1] = "Assigned";
+    /** Killed. */
+    KspRosterStatus[KspRosterStatus["Dead"] = 2] = "Dead";
+    /**
+    * Lost with a vessel. In a save with respawn enabled, a missing kerbal returns
+    * to `KspRosterStatus.Available` after a delay.
+    */
+    KspRosterStatus[KspRosterStatus["Missing"] = 3] = "Missing";
+})(KspRosterStatus || (KspRosterStatus = {}));
+/**
+* KSP's `Contracts.ParameterState`: whether one objective of a contract is
+* done. Behind `career.status.contracts[].parameters[].stateOrdinal`, beside
+* the name in `CareerContractParameter.state`.
+*
+* @category Career
+*/
+export var KspParameterState;
+(function (KspParameterState) {
+    /** Not yet met. */
+    KspParameterState[KspParameterState["Incomplete"] = 0] = "Incomplete";
+    /** Met. */
+    KspParameterState[KspParameterState["Complete"] = 1] = "Complete";
+    /** Failed, and can no longer be met. */
+    KspParameterState[KspParameterState["Failed"] = 2] = "Failed";
+})(KspParameterState || (KspParameterState = {}));
+/**
+* KSP's `PartCategories`: the editor category a part filters into. Behind
+* `vessel.parts[].categoryOrdinal`, beside the name in `VesselPart.category`.
+*
+* `KspPartCategory.none` is `-1`, not `0`, so resolve an ordinal with
+* `namesByValue`, not `namesOf`, which assumes members numbered from zero. The
+* lower-case spelling is KSP's, and the name on the wire is exactly `"none"`.
+*
+* @category Parts
+*/
+export var KspPartCategory;
+(function (KspPartCategory) {
+    /** Propulsion. */
+    KspPartCategory[KspPartCategory["Propulsion"] = 0] = "Propulsion";
+    /** Control: reaction wheels, RCS thrusters and similar. */
+    KspPartCategory[KspPartCategory["Control"] = 1] = "Control";
+    /** Structural. */
+    KspPartCategory[KspPartCategory["Structural"] = 2] = "Structural";
+    /** Aerodynamics: wings, control surfaces, nose cones, intakes. */
+    KspPartCategory[KspPartCategory["Aero"] = 3] = "Aero";
+    /** Utility. */
+    KspPartCategory[KspPartCategory["Utility"] = 4] = "Utility";
+    /** Science. */
+    KspPartCategory[KspPartCategory["Science"] = 5] = "Science";
+    /** Command pods and probe cores. */
+    KspPartCategory[KspPartCategory["Pods"] = 6] = "Pods";
+    /** Fuel tanks. */
+    KspPartCategory[KspPartCategory["FuelTank"] = 7] = "FuelTank";
+    /** Engines. */
+    KspPartCategory[KspPartCategory["Engine"] = 8] = "Engine";
+    /** Communication: antennas and relays. */
+    KspPartCategory[KspPartCategory["Communication"] = 9] = "Communication";
+    /** Electrical: batteries, generators, solar panels. */
+    KspPartCategory[KspPartCategory["Electrical"] = 10] = "Electrical";
+    /** Ground: landing gear, legs and wheels. */
+    KspPartCategory[KspPartCategory["Ground"] = 11] = "Ground";
+    /** Thermal: heat shields and radiators. */
+    KspPartCategory[KspPartCategory["Thermal"] = 12] = "Thermal";
+    /** Payload: fairings and cargo bays. */
+    KspPartCategory[KspPartCategory["Payload"] = 13] = "Payload";
+    /** Coupling: decouplers, separators and docking ports. */
+    KspPartCategory[KspPartCategory["Coupling"] = 14] = "Coupling";
+    /** Cargo: inventory parts. */
+    KspPartCategory[KspPartCategory["Cargo"] = 15] = "Cargo";
+    /** Robotics (Breaking Ground servos and rotors). */
+    KspPartCategory[KspPartCategory["Robotics"] = 16] = "Robotics";
+    /** No category. KSP spells it in lower case. */
+    KspPartCategory[KspPartCategory["none"] = -1] = "none";
+})(KspPartCategory || (KspPartCategory = {}));
+/**
+* KSP's `KSPActionGroup`: which action groups a part action fires with. Behind
+* `vessel.parts[].actionBindings[].groupsMask`, beside the names in
+* `ActionBinding.groups`.
+*
+* A `[Flags]` bitmask, so the members are powers of two and the wire carries
+* the whole mask as one integer rather than one ordinal. `KspActionGroup.None`
+* is `0` and `KspActionGroup.REPLACEWITHDEFAULT` is `-1`; neither is a group a
+* part action is usefully bound to.
+*
+* @category Vessel
+*/
+export var KspActionGroup;
+(function (KspActionGroup) {
+    /** No group. */
+    KspActionGroup[KspActionGroup["None"] = 0] = "None";
+    /** The staging group (mask value 1). */
+    KspActionGroup[KspActionGroup["Stage"] = 1] = "Stage";
+    /** The gear group (mask value 2). */
+    KspActionGroup[KspActionGroup["Gear"] = 2] = "Gear";
+    /** The lights group (mask value 4). */
+    KspActionGroup[KspActionGroup["Light"] = 4] = "Light";
+    /** The RCS group (mask value 8). */
+    KspActionGroup[KspActionGroup["RCS"] = 8] = "RCS";
+    /** The SAS group (mask value 16). */
+    KspActionGroup[KspActionGroup["SAS"] = 16] = "SAS";
+    /** The brakes group (mask value 32). */
+    KspActionGroup[KspActionGroup["Brakes"] = 32] = "Brakes";
+    /** The abort group (mask value 64). */
+    KspActionGroup[KspActionGroup["Abort"] = 64] = "Abort";
+    /** Custom action group 1 (mask value 128). */
+    KspActionGroup[KspActionGroup["Custom01"] = 128] = "Custom01";
+    /** Custom action group 2 (mask value 256). */
+    KspActionGroup[KspActionGroup["Custom02"] = 256] = "Custom02";
+    /** Custom action group 3 (mask value 512). */
+    KspActionGroup[KspActionGroup["Custom03"] = 512] = "Custom03";
+    /** Custom action group 4 (mask value 1024). */
+    KspActionGroup[KspActionGroup["Custom04"] = 1024] = "Custom04";
+    /** Custom action group 5 (mask value 2048). */
+    KspActionGroup[KspActionGroup["Custom05"] = 2048] = "Custom05";
+    /** Custom action group 6 (mask value 4096). */
+    KspActionGroup[KspActionGroup["Custom06"] = 4096] = "Custom06";
+    /** Custom action group 7 (mask value 8192). */
+    KspActionGroup[KspActionGroup["Custom07"] = 8192] = "Custom07";
+    /** Custom action group 8 (mask value 16384). */
+    KspActionGroup[KspActionGroup["Custom08"] = 16384] = "Custom08";
+    /** Custom action group 9 (mask value 32768). */
+    KspActionGroup[KspActionGroup["Custom09"] = 32768] = "Custom09";
+    /** Custom action group 10 (mask value 65536). */
+    KspActionGroup[KspActionGroup["Custom10"] = 65536] = "Custom10";
+    /** KSP's placeholder for "use the action's default group". Not a real group. */
+    KspActionGroup[KspActionGroup["REPLACEWITHDEFAULT"] = -1] = "REPLACEWITHDEFAULT";
+})(KspActionGroup || (KspActionGroup = {}));
+/**
+* KSP's `EditorFacility`: which editor a craft was built in. Behind
+* `spaceCenter.savedShips[].facilityOrdinal`, beside the name in
+* `SavedShipEntry.facility`.
+*
+* @category Space center
+*/
+export var KspEditorFacility;
+(function (KspEditorFacility) {
+    /** No editor recorded. */
+    KspEditorFacility[KspEditorFacility["None"] = 0] = "None";
+    /** The Vehicle Assembly Building. */
+    KspEditorFacility[KspEditorFacility["VAB"] = 1] = "VAB";
+    /** The Spaceplane Hangar. */
+    KspEditorFacility[KspEditorFacility["SPH"] = 2] = "SPH";
+})(KspEditorFacility || (KspEditorFacility = {}));
+/**
+* KSP's `SpaceCenterFacility`: one building at the space centre. Behind
+* `career.status.facilities[].facilityOrdinal` and
+* `LimitBreach.facilityOrdinal`.
+*
+* `career.status.facilities` is keyed by the facility name, not the ordinal.
+* The ordinal is carried inside each entry, so a client can branch on it
+* without relying on the key it arrived under.
+*
+* @category Space center
+*/
+export var KspSpaceCenterFacility;
+(function (KspSpaceCenterFacility) {
+    /** The Administration building. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["Administration"] = 0] = "Administration";
+    /** The Astronaut Complex. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["AstronautComplex"] = 1] = "AstronautComplex";
+    /** The Launch Pad. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["LaunchPad"] = 2] = "LaunchPad";
+    /** Mission Control. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["MissionControl"] = 3] = "MissionControl";
+    /** Research and Development. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["ResearchAndDevelopment"] = 4] = "ResearchAndDevelopment";
+    /** The Runway. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["Runway"] = 5] = "Runway";
+    /** The Tracking Station. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["TrackingStation"] = 6] = "TrackingStation";
+    /** The Spaceplane Hangar. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["SpaceplaneHangar"] = 7] = "SpaceplaneHangar";
+    /** The Vehicle Assembly Building. */
+    KspSpaceCenterFacility[KspSpaceCenterFacility["VehicleAssemblyBuilding"] = 8] = "VehicleAssemblyBuilding";
+})(KspSpaceCenterFacility || (KspSpaceCenterFacility = {}));
+/**
+* KSP's `ResourceFlowMode`: how a resource moves around a vessel. Behind
+* `kerbalism.resourceDefs[].flowModeOrdinal`, beside the name in
+* `ResourceDefRaw.FlowMode`.
+*
+* The enum is stock KSP's, so any Uplink that reports a resource's flow mode
+* uses this declaration.
+*
+* @category Parts
+*/
+export var KspResourceFlowMode;
+(function (KspResourceFlowMode) {
+    /** The resource does not flow between parts; each part uses only its own. */
+    KspResourceFlowMode[KspResourceFlowMode["NO_FLOW"] = 0] = "NO_FLOW";
+    /** The resource flows to any part on the vessel. */
+    KspResourceFlowMode[KspResourceFlowMode["ALL_VESSEL"] = 1] = "ALL_VESSEL";
+    /** The resource flows vessel-wide, drawn from the highest stage priority first. */
+    KspResourceFlowMode[KspResourceFlowMode["STAGE_PRIORITY_FLOW"] = 2] = "STAGE_PRIORITY_FLOW";
+    /** The resource flows along the stack through crossfeed-capable connections. */
+    KspResourceFlowMode[KspResourceFlowMode["STACK_PRIORITY_SEARCH"] = 3] = "STACK_PRIORITY_SEARCH";
+    /**
+    * As `KspResourceFlowMode.ALL_VESSEL`, drawn evenly across the containing
+    * parts.
+    */
+    KspResourceFlowMode[KspResourceFlowMode["ALL_VESSEL_BALANCE"] = 4] = "ALL_VESSEL_BALANCE";
+    /**
+    * As `KspResourceFlowMode.STAGE_PRIORITY_FLOW`, drawn evenly within a
+    * priority.
+    */
+    KspResourceFlowMode[KspResourceFlowMode["STAGE_PRIORITY_FLOW_BALANCE"] = 5] = "STAGE_PRIORITY_FLOW_BALANCE";
+    /** The resource flows within the stage through crossfeed-capable connections. */
+    KspResourceFlowMode[KspResourceFlowMode["STAGE_STACK_FLOW"] = 6] = "STAGE_STACK_FLOW";
+    /**
+    * As `KspResourceFlowMode.STAGE_STACK_FLOW`, drawn evenly across the
+    * containing parts.
+    */
+    KspResourceFlowMode[KspResourceFlowMode["STAGE_STACK_FLOW_BALANCE"] = 7] = "STAGE_STACK_FLOW_BALANCE";
+    /** No flow mode set. */
+    KspResourceFlowMode[KspResourceFlowMode["NULL"] = 8] = "NULL";
+})(KspResourceFlowMode || (KspResourceFlowMode = {}));
+/**
+* Whether a payload's subject is simulated under physics (`Quality.Loaded`) or
+* moving on rails (`Quality.OnRails`).
+*
+* @category Stream messages
+*/
 export var Quality;
 (function (Quality) {
+    /** Moving on rails: KSP is not simulating it, and its orbit is a fixed conic. */
     Quality[Quality["OnRails"] = 0] = "OnRails";
+    /** Loaded and simulated under physics. */
     Quality[Quality["Loaded"] = 1] = "Loaded";
 })(Quality || (Quality = {}));
+/**
+* How current a delivered sample is, as the mod knows it (a client infers the
+* rest from its own heartbeat tracking).
+*
+* `Staleness.Fresh` is a sample delivered on its own schedule.
+* `Staleness.Held` and `Staleness.LastBeforeBlackout` are catch-up grades for
+* a late or reconnecting subscriber. `Staleness.Recorded` is different in kind
+* from all three: the sample is exact as of its own `Meta.validAt`, it simply
+* did not travel at the time it was taken. It was held aboard through a loss
+* of signal and dumped on acquisition, so it arrives long after the instant it
+* describes, and its `Meta.deliveredAt` is the real arrival, not `validAt +
+* light-time`.
+*
+* @category Stream messages
+*/
 export var Staleness;
 (function (Staleness) {
+    /**
+    * Delivered on its own schedule. An old `validAt` on a Topic that sends only
+    * on change is still fresh.
+    */
     Staleness[Staleness["Fresh"] = 0] = "Fresh";
-    Staleness[Staleness["HeldStale"] = 1] = "HeldStale";
+    /**
+    * Sent to a subscriber that joined while contact was lost, and taken after
+    * contact was lost.
+    */
+    Staleness[Staleness["Held"] = 1] = "Held";
+    /**
+    * Sent to a subscriber that joined while contact was lost: the last sample
+    * that got out before contact was lost.
+    */
     Staleness[Staleness["LastBeforeBlackout"] = 2] = "LastBeforeBlackout";
+    /**
+    * Recovered from the subject's own recorder: taken while it was out of
+    * contact, replayed on reacquisition. Precisely dated and never a guess, but
+    * not a live reading, and never the subject's current state.
+    */
+    Staleness[Staleness["Recorded"] = 3] = "Recorded";
 })(Staleness || (Staleness = {}));
+/**
+* Where one Making History mission objective stands, defined by this contract
+* rather than by KSP.
+*
+* KSP's mission graph has no per-objective state. A node is either activated
+* (the mission reached it) or not, and exactly one node is the mission's
+* active node, so this reduces those facts to the four outcomes an operator
+* reads. On the wire it is an integer ordinal.
+*
+* @category Missions
+*/
+export var MissionObjectiveState;
+(function (MissionObjectiveState) {
+    /** The mission has not reached this objective yet. */
+    MissionObjectiveState[MissionObjectiveState["Pending"] = 0] = "Pending";
+    /**
+    * The mission is on this objective now: it is the mission's active node and
+    * the mission is still running.
+    */
+    MissionObjectiveState[MissionObjectiveState["Active"] = 1] = "Active";
+    /**
+    * The mission reached this objective and has moved past it, or ended
+    * successfully on it.
+    */
+    MissionObjectiveState[MissionObjectiveState["Reached"] = 2] = "Reached";
+    /** The mission ended without success before this objective was met. */
+    MissionObjectiveState[MissionObjectiveState["Failed"] = 3] = "Failed";
+})(MissionObjectiveState || (MissionObjectiveState = {}));
+/**
+* Which kind of condition a SCET alarm watches for.
+*
+* Every alarm has a vantage, so a kind says only what is watched. A threshold
+* follows a dotted path to a number; a contract parameter, which sits in a
+* list no path can index, finds its contract and objective by id and title.
+*
+* @category Alarms
+*/
+export var ScetAlarmConditionKind;
+(function (ScetAlarmConditionKind) {
+    /** An instant on the craft's own clock, as a universal time. */
+    ScetAlarmConditionKind[ScetAlarmConditionKind["Time"] = 0] = "Time";
+    /**
+    * A value aboard the craft crossing a number the operator chose, compared
+    * against the reading the simulation actually holds rather than against the
+    * one the command centre has been told.
+    *
+    * Only the simulation can check this. A time alarm needs only a clock, which a
+    * client has; a threshold needs the craft's true state, which reaches the
+    * ground a light-time late and by then no longer says whether the craft is
+    * above 100 km now.
+    */
+    ScetAlarmConditionKind[ScetAlarmConditionKind["Threshold"] = 1] = "Threshold";
+    /**
+    * One objective of one active contract reaching a state the operator chose, as
+    * `career.status.contracts.active` reports it.
+    *
+    * Level rather than edge, like the threshold: an objective already in its
+    * target state when the alarm is set is a condition that holds. A contract no
+    * longer active leaves the condition unmet for ever, which is the fail-safe
+    * outcome for a contract that was completed, failed or withdrawn by some other
+    * route.
+    */
+    ScetAlarmConditionKind[ScetAlarmConditionKind["ContractParameter"] = 2] = "ContractParameter";
+})(ScetAlarmConditionKind || (ScetAlarmConditionKind = {}));
+/**
+* How a threshold condition compares the reading to the operator's number.
+*
+* The same six the client's own alarm list offers, so an alarm set on the
+* command vantage and the same alarm set on the craft's clock mean the same
+* thing and can be checked against each other at zero delay.
+*
+* @category Alarms
+*/
+export var ScetAlarmThresholdOp;
+(function (ScetAlarmThresholdOp) {
+    /** Reading is greater than the threshold. */
+    ScetAlarmThresholdOp[ScetAlarmThresholdOp["GreaterThan"] = 0] = "GreaterThan";
+    /** Reading is greater than or equal to the threshold. */
+    ScetAlarmThresholdOp[ScetAlarmThresholdOp["GreaterThanOrEqual"] = 1] = "GreaterThanOrEqual";
+    /** Reading is less than the threshold. */
+    ScetAlarmThresholdOp[ScetAlarmThresholdOp["LessThan"] = 2] = "LessThan";
+    /** Reading is less than or equal to the threshold. */
+    ScetAlarmThresholdOp[ScetAlarmThresholdOp["LessThanOrEqual"] = 3] = "LessThanOrEqual";
+    /**
+    * Reading equals the threshold exactly.
+    *
+    * Offered for parity with the client's list, and a knife edge on anything
+    * continuous: the reading is a sample, and under warp the samples are
+    * thousands of game-seconds apart, so a craft can pass straight through the
+    * value without one landing on it. An inequality is almost always the
+    * condition an operator actually means.
+    */
+    ScetAlarmThresholdOp[ScetAlarmThresholdOp["Equal"] = 4] = "Equal";
+    /**
+    * Reading differs from the threshold. The inverse of
+    * `ScetAlarmThresholdOp.Equal`, and just as much a knife edge on anything
+    * continuous.
+    */
+    ScetAlarmThresholdOp[ScetAlarmThresholdOp["NotEqual"] = 5] = "NotEqual";
+})(ScetAlarmThresholdOp || (ScetAlarmThresholdOp = {}));
+/**
+* Where a SCET alarm has got to.
+*
+* A latch, not a level: `ScetAlarmState.Fired` is reached once and stays, so a
+* condition that keeps holding cannot stop the warp again on the next tick.
+*
+* @category Alarms
+*/
+export var ScetAlarmState;
+(function (ScetAlarmState) {
+    /** Watching. The condition has not been met. */
+    ScetAlarmState[ScetAlarmState["Armed"] = 0] = "Armed";
+    /** The condition was met, warp was stopped, and the notice went out. */
+    ScetAlarmState[ScetAlarmState["Fired"] = 1] = "Fired";
+    /**
+    * The craft the condition watches no longer exists, so the alarm can never
+    * come due.
+    *
+    * Only a threshold reaches this: a time condition has no subject to lose,
+    * because universal time belongs to the game. The simulation knows the craft
+    * is gone before the command centre does, so show such a row as dead rather
+    * than as pending.
+    */
+    ScetAlarmState[ScetAlarmState["Unreachable"] = 2] = "Unreachable";
+    /**
+    * The player switched to a different craft before the alarm came due, so it
+    * will never fire. An alarm belongs to the craft being flown when it was set,
+    * whatever its condition reads, and a switch ends every alarm still watching.
+    * A kerbal on EVA counts as the craft they stepped out of.
+    */
+    ScetAlarmState[ScetAlarmState["Cancelled"] = 3] = "Cancelled";
+})(ScetAlarmState || (ScetAlarmState = {}));
+/**
+* What a SCET alarm's onboard action does to the craft when the alarm fires.
+*
+* A typed member for each stock singleton and one for every custom group, so
+* no name ever crosses the wire. A player may call a custom group "Stage", and
+* two custom groups may share a name, so a name is not an identity: a custom
+* group is addressed by its index in `ScetAlarmAction.group`, and cannot be
+* read as the stage command however it is labelled.
+*
+* @category Alarms
+*/
+export var ScetAlarmActionKind;
+(function (ScetAlarmActionKind) {
+    /** Toggle the custom action group whose index is `ScetAlarmAction.group`. */
+    ScetAlarmActionKind[ScetAlarmActionKind["ActionGroup"] = 0] = "ActionGroup";
+    /** Activate the next stage. */
+    ScetAlarmActionKind[ScetAlarmActionKind["Stage"] = 1] = "Stage";
+    /** Toggle SAS. */
+    ScetAlarmActionKind[ScetAlarmActionKind["Sas"] = 2] = "Sas";
+    /** Toggle RCS. */
+    ScetAlarmActionKind[ScetAlarmActionKind["Rcs"] = 3] = "Rcs";
+    /** Toggle the lights. */
+    ScetAlarmActionKind[ScetAlarmActionKind["Lights"] = 4] = "Lights";
+    /** Toggle the landing gear. */
+    ScetAlarmActionKind[ScetAlarmActionKind["Gear"] = 5] = "Gear";
+    /** Toggle the brakes. */
+    ScetAlarmActionKind[ScetAlarmActionKind["Brakes"] = 6] = "Brakes";
+    /** Toggle the abort action group. */
+    ScetAlarmActionKind[ScetAlarmActionKind["Abort"] = 7] = "Abort";
+})(ScetAlarmActionKind || (ScetAlarmActionKind = {}));
+/**
+* A deployed-science cluster's power state, defined by this contract rather
+* than by KSP.
+*
+* KSP has no enum for this. `ModuleGroundSciencePart` carries the state as a
+* localised sentence, so this reproduces the five outcomes `UpdateModuleUI()`
+* distinguishes, derived from the booleans it reads rather than from the
+* sentence it writes. It is an ordinal on the wire and a closed union on the
+* client like every other enum in this contract.
+*
+* @category Science
+*/
+export var DeployedPowerState;
+(function (DeployedPowerState) {
+    /** Powered and working: the cluster reports `IsPowered`. */
+    DeployedPowerState[DeployedPowerState["Powered"] = 0] = "Powered";
+    /** Deployed and switched on, but the cluster has no power. */
+    DeployedPowerState[DeployedPowerState["Unpowered"] = 1] = "Unpowered";
+    /** The cluster's controller is switched off, so nothing is powered. */
+    DeployedPowerState[DeployedPowerState["ControllerDisabled"] = 2] = "ControllerDisabled";
+    /** This experiment is switched off, or is not deployed on the ground. */
+    DeployedPowerState[DeployedPowerState["Disabled"] = 3] = "Disabled";
+    /**
+    * Attached to no cluster at all. Distinct from `DeployedPowerState.Unpowered`:
+    * there is nothing to supply power, rather than a supply that is empty.
+    */
+    DeployedPowerState[DeployedPowerState["NotConnected"] = 4] = "NotConnected";
+})(DeployedPowerState || (DeployedPowerState = {}));
+/**
+* Where the settings in force stand against the settings file.
+*
+* @category Mod settings
+*/
+export var SettingsPersistenceState;
+(function (SettingsPersistenceState) {
+    /**
+    * The file holds these values: it was read at start-up, or the last save wrote
+    * it.
+    */
+    SettingsPersistenceState[SettingsPersistenceState["Saved"] = 0] = "Saved";
+    /**
+    * The last save could not write the file. The values are in force for this
+    * session only and revert when KSP restarts; `SettingsPersistence.reason` says
+    * why.
+    */
+    SettingsPersistenceState[SettingsPersistenceState["MemoryOnly"] = 1] = "MemoryOnly";
+    /**
+    * The file was missing, empty or damaged at start-up, and its backup was read
+    * instead. Anything saved after that backup was taken is lost. Clears at the
+    * next successful save.
+    */
+    SettingsPersistenceState[SettingsPersistenceState["Recovered"] = 2] = "Recovered";
+    /**
+    * No settings file exists yet: a first run, every setting at its default until
+    * the first save.
+    */
+    SettingsPersistenceState[SettingsPersistenceState["Defaults"] = 3] = "Defaults";
+    /**
+    * A settings file exists but neither it nor a backup could be read, so every
+    * setting is at its default. Clears at the next successful save, which
+    * replaces the unreadable file.
+    */
+    SettingsPersistenceState[SettingsPersistenceState["Unreadable"] = 4] = "Unreadable";
+})(SettingsPersistenceState || (SettingsPersistenceState = {}));
+/**
+* A roster vessel's control level, as stock CommNet reports it
+* (`Vessel.connection.GetControlLevel()`), for
+* `VesselRosterEntry.commsControlSource`. Not the same type as
+* `CommsControlSource`, which belongs to the active vessel's `comms.*`
+* channels and whatever comms mod provides them.
+*
+* @category Solar system and fleet
+*/
+export var RosterCommsControlSource;
+(function (RosterCommsControlSource) {
+    /** A measurement: the vessel has no control source. */
+    RosterCommsControlSource[RosterCommsControlSource["None"] = 0] = "None";
+    /**
+    * Partial control: KSP's `PARTIAL_MANNED` or `PARTIAL_UNMANNED` level, such as
+    * a probe core with no link home.
+    */
+    RosterCommsControlSource[RosterCommsControlSource["Partial"] = 1] = "Partial";
+    /** Full control: KSP's `FULL` level. */
+    RosterCommsControlSource[RosterCommsControlSource["Full"] = 2] = "Full";
+    /**
+    * The game reported a control level this build does not name. Not
+    * `RosterCommsControlSource.None`: nothing was measured to be absent, the
+    * level simply has no tier here yet.
+    */
+    RosterCommsControlSource[RosterCommsControlSource["Unknown"] = 3] = "Unknown";
+})(RosterCommsControlSource || (RosterCommsControlSource = {}));
+/**
+* How the active vessel comes to know of another vessel on `target.available`,
+* which is also how old what it knows can be.
+*
+* @category Orbits and trajectories
+*/
+export var TargetKnowledge;
+(function (TargetKnowledge) {
+    /**
+    * The other vessel is within physics range of the active vessel, which sees it
+    * as it is.
+    */
+    TargetKnowledge[TargetKnowledge["InRange"] = 0] = "InRange";
+    /**
+    * The other vessel's radio reaches the active vessel directly, so what is
+    * known of it is one light-time of that link old.
+    */
+    TargetKnowledge[TargetKnowledge["DirectLink"] = 1] = "DirectLink";
+    /**
+    * The active vessel's command centre knows of the other vessel, by tracking it
+    * or by hearing from it, and has told the active vessel over its control
+    * route. What is known is as old as the centre's own knowledge plus that
+    * route's light-time.
+    */
+    TargetKnowledge[TargetKnowledge["CommandCentre"] = 2] = "CommandCentre";
+})(TargetKnowledge || (TargetKnowledge = {}));
+/**
+* What a command gate concluded about one precondition: passed, failed, could
+* not be decided from the arguments supplied, or could not be decided from the
+* game's state.
+*
+* @category System diagnostics
+*/
+export var GateOutcome;
+(function (GateOutcome) {
+    /** Nothing blocks this. */
+    GateOutcome[GateOutcome["Pass"] = 0] = "Pass";
+    /** Blocked, with the comparison that says why. */
+    GateOutcome[GateOutcome["Fail"] = 1] = "Fail";
+    /**
+    * Cannot be decided from the arguments supplied, because one it needs is
+    * missing. Not a refusal: a client that treats this as blocked disables every
+    * argument-dependent control permanently.
+    */
+    GateOutcome[GateOutcome["Abstain"] = 2] = "Abstain";
+    /**
+    * Decidable in principle, but the live state needed is missing, e.g. a
+    * facility KSP does not track under the name declared. Distinct from
+    * `GateOutcome.Abstain` because nothing further the caller supplies will
+    * resolve it, and distinct from `GateOutcome.Pass` because an unreadable limit
+    * is not the same as no limit.
+    */
+    GateOutcome[GateOutcome["Unknown"] = 3] = "Unknown";
+})(GateOutcome || (GateOutcome = {}));
+/**
+* What a setting may hold, the mod's own or an Uplink's.
+*
+* The set is small and closed. A setting that needs more than these is a
+* `SettingKind.Text` row that the Uplink checks when it reads it.
+*
+* @category Mod settings
+*/
+export var SettingKind;
+(function (SettingKind) {
+    /**
+    * A single line of text. Also the fallback for anything the other kinds cannot
+    * express.
+    */
+    SettingKind[SettingKind["Text"] = 0] = "Text";
+    /** True or false. */
+    SettingKind[SettingKind["Bool"] = 1] = "Bool";
+    /**
+    * A number, written with a full stop for the decimal point whatever the locale
+    * of the machine the game runs on.
+    */
+    SettingKind[SettingKind["Number"] = 2] = "Number";
+})(SettingKind || (SettingKind = {}));
+/**
+* KSP's `VesselControlState`, carried by name: what is controlling the vessel
+* (a probe core, a kerbal) and how much control it has (none, partial, full).
+* Mirrors the stock member names; `ControlState.Unknown` covers any name the
+* mod does not recognise.
+*
+* @category Comms
+*/
 export var ControlState;
 (function (ControlState) {
+    /** No control. */
     ControlState[ControlState["None"] = 0] = "None";
+    /** Controlled by a probe core. */
     ControlState[ControlState["Probe"] = 1] = "Probe";
+    /** Controlled by a kerbal. */
     ControlState[ControlState["Kerbal"] = 2] = "Kerbal";
+    /** Partial control. */
     ControlState[ControlState["Partial"] = 3] = "Partial";
+    /** Full control. */
     ControlState[ControlState["Full"] = 4] = "Full";
+    /** A probe-controlled vessel with no control. */
     ControlState[ControlState["ProbeNone"] = 5] = "ProbeNone";
+    /**
+    * A probe-controlled vessel with partial control, typically without a
+    * connection home.
+    */
     ControlState[ControlState["ProbePartial"] = 6] = "ProbePartial";
+    /** A probe-controlled vessel with full control. */
     ControlState[ControlState["ProbeFull"] = 7] = "ProbeFull";
+    /** A kerbal-controlled vessel with no control. */
     ControlState[ControlState["KerbalNone"] = 8] = "KerbalNone";
+    /** A kerbal-controlled vessel with partial control. */
     ControlState[ControlState["KerbalPartial"] = 9] = "KerbalPartial";
+    /** A kerbal-controlled vessel with full control. */
     ControlState[ControlState["KerbalFull"] = 10] = "KerbalFull";
+    /** A state name the mod does not recognise. */
     ControlState[ControlState["Unknown"] = 11] = "Unknown";
 })(ControlState || (ControlState = {}));
+/**
+* The SAS autopilot's hold mode, KSP's `VesselAutopilot.AutopilotMode` with
+* the same member names. The directional modes follow the navball's current
+* speed mode (orbit, surface or target). `SasMode.Unknown` stands for a value
+* this contract does not recognise.
+*
+* @category Vessel
+*/
 export var SasMode;
 (function (SasMode) {
+    /** Holds the vessel's current attitude. */
     SasMode[SasMode["StabilityAssist"] = 0] = "StabilityAssist";
+    /** Points along the velocity vector. */
     SasMode[SasMode["Prograde"] = 1] = "Prograde";
+    /** Points against the velocity vector. */
     SasMode[SasMode["Retrograde"] = 2] = "Retrograde";
+    /** Points along the orbit normal. */
     SasMode[SasMode["Normal"] = 3] = "Normal";
+    /** Points against the orbit normal. */
     SasMode[SasMode["Antinormal"] = 4] = "Antinormal";
+    /** Points towards the body being orbited. */
     SasMode[SasMode["RadialIn"] = 5] = "RadialIn";
+    /** Points away from the body being orbited. */
     SasMode[SasMode["RadialOut"] = 6] = "RadialOut";
+    /** Points towards the current target. */
     SasMode[SasMode["Target"] = 7] = "Target";
+    /** Points away from the current target. */
     SasMode[SasMode["AntiTarget"] = 8] = "AntiTarget";
+    /** Points along the burn vector of the next maneuver node. */
     SasMode[SasMode["Maneuver"] = 9] = "Maneuver";
+    /** A mode this contract does not recognise. */
     SasMode[SasMode["Unknown"] = 10] = "Unknown";
 })(SasMode || (SasMode = {}));
+/**
+* A vessel's flight situation, KSP's `Vessel.situation` (the
+* `Vessel.Situations` enum) in this contract's PascalCase spelling.
+* `Situation.Unknown` stands for a value this contract does not recognise,
+* such as a situation added by a later KSP version.
+*
+* @category Vessel
+*/
 export var Situation;
 (function (Situation) {
+    /** Resting on the surface of a body (KSP `LANDED`). */
     Situation[Situation["Landed"] = 0] = "Landed";
+    /** Floating on water (KSP `SPLASHED`). */
     Situation[Situation["Splashed"] = 1] = "Splashed";
+    /** On the launch pad or runway and not yet launched (KSP `PRELAUNCH`). */
     Situation[Situation["PreLaunch"] = 2] = "PreLaunch";
+    /**
+    * In a closed orbit that does not intersect the surface or atmosphere (KSP
+    * `ORBITING`).
+    */
     Situation[Situation["Orbiting"] = 3] = "Orbiting";
+    /**
+    * On a trajectory that leaves the current body's sphere of influence (KSP
+    * `ESCAPING`).
+    */
     Situation[Situation["Escaping"] = 4] = "Escaping";
+    /** In the atmosphere and off the ground (KSP `FLYING`). */
     Situation[Situation["Flying"] = 5] = "Flying";
+    /**
+    * Above the atmosphere on a trajectory that meets the surface or atmosphere
+    * again (KSP `SUB_ORBITAL`).
+    */
     Situation[Situation["SubOrbital"] = 6] = "SubOrbital";
+    /** Docked to another vessel (KSP `DOCKED`). */
     Situation[Situation["Docked"] = 7] = "Docked";
+    /** A situation this contract does not recognise. */
     Situation[Situation["Unknown"] = 8] = "Unknown";
 })(Situation || (Situation = {}));
+/**
+* A vessel's type, KSP's `Vessel.vesselType` (the `VesselType` enum), with the
+* same member names. `VesselType.Unknown` is both KSP's own `Unknown` type and
+* the value for a type this contract does not recognise.
+*
+* @category Vessel
+*/
 export var VesselType;
 (function (VesselType) {
+    /** A crewed or general-purpose ship. */
     VesselType[VesselType["Ship"] = 0] = "Ship";
+    /** A space station. */
     VesselType[VesselType["Station"] = 1] = "Station";
+    /** A lander. */
     VesselType[VesselType["Lander"] = 2] = "Lander";
+    /** An uncrewed probe. */
     VesselType[VesselType["Probe"] = 3] = "Probe";
+    /** A rover. */
     VesselType[VesselType["Rover"] = 4] = "Rover";
+    /** A surface base. */
     VesselType[VesselType["Base"] = 5] = "Base";
+    /** A communications relay. */
     VesselType[VesselType["Relay"] = 6] = "Relay";
+    /** A kerbal on EVA. */
     VesselType[VesselType["EVA"] = 7] = "EVA";
+    /** A planted flag. */
     VesselType[VesselType["Flag"] = 8] = "Flag";
+    /** Debris, such as a spent stage or a jettisoned fairing. */
     VesselType[VesselType["Debris"] = 9] = "Debris";
+    /** An asteroid or comet. */
     VesselType[VesselType["SpaceObject"] = 10] = "SpaceObject";
+    /** A deployed science station's central control unit (Breaking Ground). */
     VesselType[VesselType["DeployedScienceController"] = 11] = "DeployedScienceController";
+    /**
+    * A deployed science experiment or power part other than the controller
+    * (Breaking Ground).
+    */
     VesselType[VesselType["DeployedSciencePart"] = 12] = "DeployedSciencePart";
+    /** A part dropped from a vessel, such as a piece of ground equipment. */
     VesselType[VesselType["DroppedPart"] = 13] = "DroppedPart";
+    /** KSP's own unknown type, or a type this contract does not recognise. */
     VesselType[VesselType["Unknown"] = 14] = "Unknown";
 })(VesselType || (VesselType = {}));
+/**
+* How an orbit patch begins or ends, KSP's `Orbit.PatchTransitionType` (read
+* from `Orbit.patchStartTransition` and `Orbit.patchEndTransition`). Member
+* names follow KSP's except `TransitionType.Collision`, which is KSP's
+* `IMPACT`. `TransitionType.Unknown` stands for a value this contract does not
+* recognise.
+*
+* @category Vessel
+*/
 export var TransitionType;
 (function (TransitionType) {
+    /**
+    * The patch starts at the vessel's current position: the first patch of a
+    * trajectory.
+    */
     TransitionType[TransitionType["Initial"] = 0] = "Initial";
+    /**
+    * The patch does not end in a transition: the trajectory continues on it
+    * indefinitely.
+    */
     TransitionType[TransitionType["Final"] = 1] = "Final";
+    /** The trajectory enters another body's sphere of influence. */
     TransitionType[TransitionType["Encounter"] = 2] = "Encounter";
+    /** The trajectory leaves the current body's sphere of influence. */
     TransitionType[TransitionType["Escape"] = 3] = "Escape";
+    /** The patch ends or begins at a planned maneuver node. */
     TransitionType[TransitionType["Maneuver"] = 4] = "Maneuver";
+    /**
+    * The trajectory meets the body's surface (KSP `IMPACT`), with or without an
+    * atmosphere.
+    */
     TransitionType[TransitionType["Collision"] = 5] = "Collision";
+    /** A transition this contract does not recognise. */
     TransitionType[TransitionType["Unknown"] = 6] = "Unknown";
 })(TransitionType || (TransitionType = {}));
+/**
+* The basis a planned burn's delta-v components are expressed in. Read this
+* before interpreting a burn vector: a basis this contract does not recognise
+* gives components that cannot be labelled.
+*
+* @category Orbits and trajectories
+*/
+export var ManeuverFrame;
+(function (ManeuverFrame) {
+    /**
+    * KSP's own maneuver-node basis: radial-out, normal, prograde, taken against
+    * the patch the node sits on at its own UT.
+    */
+    ManeuverFrame[ManeuverFrame["RadialNormalPrograde"] = 0] = "RadialNormalPrograde";
+    /** A frame this contract does not recognise. */
+    ManeuverFrame[ManeuverFrame["Unknown"] = 1] = "Unknown";
+})(ManeuverFrame || (ManeuverFrame = {}));
+/**
+* How far an element set may be carried forward.
+*
+* `PropagationHorizonKind.Unspecified` is 0, so a producer that does not set
+* the horizon gets the refusing value rather than the permissive one.
+*
+* `PropagationHorizonKind.Unbounded` is a claim, made by a provider that
+* genuinely has no limit (an analytic two-body solver). It is its own value
+* rather than an infinite `PropagationHorizon.untilUt`, so "forever" never has
+* to be recognised as an extreme number.
+*
+* @category Orbits and trajectories
+*/
+export var PropagationHorizonKind;
+(function (PropagationHorizonKind) {
+    /** No provider stated one. Treat as unpropagatable. */
+    PropagationHorizonKind[PropagationHorizonKind["Unspecified"] = 0] = "Unspecified";
+    /** Authoritative for all future UT: an analytic solver with no horizon. */
+    PropagationHorizonKind[PropagationHorizonKind["Unbounded"] = 1] = "Unbounded";
+    /** Authoritative until `PropagationHorizon.untilUt`. */
+    PropagationHorizonKind[PropagationHorizonKind["Until"] = 2] = "Until";
+})(PropagationHorizonKind || (PropagationHorizonKind = {}));
+/**
+* What kind of thing an element set describes: a closed-form conic, or a
+* snapshot of an integrated path.
+*
+* `TrajectoryKind.Unspecified` is 0 for the same reason as
+* `PropagationHorizonKind.Unspecified`: a producer that does not set the field
+* gets the value that withholds rather than the one that permits.
+*
+* @category Orbits and trajectories
+*/
+export var TrajectoryKind;
+(function (TrajectoryKind) {
+    /** No provider stated one. Treat the shape as unknown. */
+    TrajectoryKind[TrajectoryKind["Unspecified"] = 0] = "Unspecified";
+    /**
+    * A closed-form conic. The orbit is that conic, so a conic renderer is exactly
+    * right and stays right for as long as the horizon allows.
+    */
+    TrajectoryKind[TrajectoryKind["Analytic"] = 1] = "Analytic";
+    /**
+    * A numerically integrated path. The osculating conic on the wire is a
+    * snapshot of it, true at the sample instant and never the path itself, so a
+    * client that draws a closed ellipse from it is drawing something the craft
+    * will not fly.
+    */
+    TrajectoryKind[TrajectoryKind["Integrated"] = 2] = "Integrated";
+})(TrajectoryKind || (TrajectoryKind = {}));
+/**
+* The active vessel's physics-simulation regime, derived from KSP's own
+* `Vessel.loaded` and `Vessel.packed` flags. It is a discrete enum in its own
+* right, not a quality band on `OrbitPayloadMeta.quality`. A widget that
+* switches propagation or dead-reckoning strategy reads it to know whether the
+* craft is on-rails conics, a packed cluster, or a fully physics-simulated
+* vessel.
+*
+* Mapping:
+*
+* - `!loaded` ⇒ `PhysicsMode.OnRails`: the vessel is unloaded, its motion is
+*   pure on-rails conic propagation, no PhysX at all.
+* - `loaded && packed` ⇒ `PhysicsMode.Packed`: loaded into the scene but still
+*   packed (rails-following near the active vessel, not yet unpacked into full
+*   physics).
+* - `loaded && !packed` ⇒ `PhysicsMode.Unpacked`: fully physics-simulated
+*   (off-rails).
+*
+* `PhysicsMode.Unknown` covers a raw value this contract does not recognise
+* (same convention as `SasMode` and `VesselType`).
+*
+* @category Vessel
+*/
 export var PhysicsMode;
 (function (PhysicsMode) {
+    /** Not loaded: pure on-rails conic propagation, no physics simulation. */
     PhysicsMode[PhysicsMode["OnRails"] = 0] = "OnRails";
+    /**
+    * Loaded into the scene but still packed, following rails near the active
+    * vessel.
+    */
     PhysicsMode[PhysicsMode["Packed"] = 1] = "Packed";
+    /** Loaded and unpacked: fully physics-simulated, off rails. */
     PhysicsMode[PhysicsMode["Unpacked"] = 2] = "Unpacked";
+    /** A raw value this contract does not recognise. */
     PhysicsMode[PhysicsMode["Unknown"] = 3] = "Unknown";
 })(PhysicsMode || (PhysicsMode = {}));
+/**
+* Coarse classification of what `vessel.target` points at: a vessel, a
+* celestial body, a part of a vessel (a docking port), or `TargetKind.Other`
+* for anything not classified more finely (a waypoint, for instance). A more
+* specific kind may be added later; treat an unrecognised value as
+* `TargetKind.Other`.
+*
+* Member order is wire-significant, so members are only ever appended.
+*
+* `TargetKind.Position` is used only as an input to `vessel.target.set` (see
+* `SetTargetArgs.latitude` and `SetTargetArgs.longitude`): a map-picked
+* latitude and longitude that no live KSP target object backs, so it never
+* appears as `vessel.target`'s own reported `VesselTarget.kind`.
+*
+* @category Orbits and trajectories
+*/
 export var TargetKind;
 (function (TargetKind) {
+    /** A vessel. `VesselTarget.vesselId` carries its guid. */
     TargetKind[TargetKind["Vessel"] = 0] = "Vessel";
+    /**
+    * A celestial body. `VesselTarget.bodyIndex` carries its `system.bodies`
+    * index.
+    */
     TargetKind[TargetKind["Body"] = 1] = "Body";
+    /** Anything not classified more finely, such as a waypoint. Carries no id. */
     TargetKind[TargetKind["Other"] = 2] = "Other";
+    /**
+    * A surface latitude and longitude, used only as a `vessel.target.set` input
+    * and never reported.
+    */
+    TargetKind[TargetKind["Position"] = 3] = "Position";
+    /**
+    * A part of a vessel: in practice a docking port (`ModuleDockingNode`, which
+    * implements `ITargetable`). Identity is the owning vessel's
+    * `VesselTarget.vesselId` guid plus the part's `VesselTarget.partId` (KSP
+    * `Part.flightID`): a part id alone is not globally unique, only within its
+    * vessel.
+    */
+    TargetKind[TargetKind["Part"] = 4] = "Part";
 })(TargetKind || (TargetKind = {}));
+/**
+* KSP's time-warp mode, mirroring its `TimeWarp.Modes` enum, which has only
+* `HIGH` and `LOW`. `WarpMode.Unknown` covers a raw value KSP reports that
+* neither matches.
+*
+* @category Game
+*/
 export var WarpMode;
 (function (WarpMode) {
+    /** On-rails time warp (KSP's `HIGH` mode). */
     WarpMode[WarpMode["High"] = 0] = "High";
+    /** Physics warp (KSP's `LOW` mode). */
     WarpMode[WarpMode["Low"] = 1] = "Low";
+    /** KSP reported a mode this contract does not know. */
     WarpMode[WarpMode["Unknown"] = 2] = "Unknown";
 })(WarpMode || (WarpMode = {}));
+/**
+* Whether a caller accepts a result past the span the provider vouches for. It
+* chooses certification, not which model runs: both values get the same model
+* from the same provider.
+*
+* `PropagationCertification.Unspecified` is zero and means nothing was chosen,
+* so a default value never grants the permissive setting.
+*
+* @category Orbits and trajectories
+*/
+export var PropagationCertification;
+(function (PropagationCertification) {
+    /**
+    * Nothing was chosen. A request carrying this is refused rather than given a
+    * default.
+    */
+    PropagationCertification[PropagationCertification["Unspecified"] = 0] = "Unspecified";
+    /**
+    * Return a result wherever the solver can reach, past any horizon. For a
+    * planning search, such as a transfer grid, which asks a two-body question
+    * about future instants on purpose.
+    */
+    PropagationCertification[PropagationCertification["Unbounded"] = 1] = "Unbounded";
+    /**
+    * Return results only across spans the provider vouches for, and decline past
+    * them. For an operational prediction, such as when a link will be reacquired,
+    * where a time read off an unvouched arc would look certain without being so.
+    */
+    PropagationCertification[PropagationCertification["CertifiedOnly"] = 2] = "CertifiedOnly";
+})(PropagationCertification || (PropagationCertification = {}));
+/**
+* The kinds of reference frame a control frame can be: the five frame types an
+* n-body physics mod offers, plus `ControlFrameKind.Unspecified`.
+*
+* This is a superset of the frames a widget can draw in, which cover three of
+* these. A control frame outside that subset is a real state, not an error: a
+* widget set to follow the control frame then resolves to nothing.
+*
+* @category Vessel
+*/
+export var ControlFrameKind;
+(function (ControlFrameKind) {
+    /**
+    * No kind was stated, including for the target frame (see
+    * `ControlFrame.targetFrameSelected`).
+    */
+    ControlFrameKind[ControlFrameKind["Unspecified"] = 0] = "Unspecified";
+    /** Centred on a body, axes fixed against the stars. */
+    ControlFrameKind[ControlFrameKind["BodyCentredInertial"] = 1] = "BodyCentredInertial";
+    /**
+    * Centred on a body, one axis held towards another body: the frame a widget's
+    * read frame calls "parent direction".
+    */
+    ControlFrameKind[ControlFrameKind["BodyCentredBodyDirection"] = 2] = "BodyCentredBodyDirection";
+    /** Turning with the barycentre of two bodies. */
+    ControlFrameKind[ControlFrameKind["BarycentricRotating"] = 3] = "BarycentricRotating";
+    /**
+    * Turning with a pair of bodies and holding the separation of their two mass
+    * centres fixed, so a transfer between them draws the same shape whatever
+    * their current distance.
+    */
+    ControlFrameKind[ControlFrameKind["RotatingPulsating"] = 4] = "RotatingPulsating";
+    /** Centred on a body and turning with its surface. */
+    ControlFrameKind[ControlFrameKind["BodySurface"] = 5] = "BodySurface";
+})(ControlFrameKind || (ControlFrameKind = {}));
 //# sourceMappingURL=contract.js.map