@rise-maritime/keelson-js 0.5.3 → 0.6.0-alpha.202.dev.1

package/dist/payloads/Route.d.ts

@@ -0,0 +1,662 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Coordinate } from "./Coordinate";
+import { SeverityLevel } from "./Severity";
+import { GeoJSON } from "./foxglove/GeoJSON";
+import { LocationFix } from "./foxglove/LocationFix";
+import { Any } from "./google/protobuf/any";
+import { Duration } from "./google/protobuf/duration";
+/** Autonomy level the route is authored for. */
+export declare enum AutonomyLevel {
+    AUTONOMY_LEVEL_UNSPECIFIED = 0,
+    AUTONOMY_LEVEL_MANUAL_ONLY = 1,
+    AUTONOMY_LEVEL_REMOTE_CONTROLLED = 2,
+    AUTONOMY_LEVEL_AUTONOMOUS_SUPERVISED = 3,
+    AUTONOMY_LEVEL_AUTONOMOUS_UNSUPERVISED = 4,
+    UNRECOGNIZED = -1
+}
+export declare function autonomyLevelFromJSON(object: any): AutonomyLevel;
+export declare function autonomyLevelToJSON(object: AutonomyLevel): string;
+/** Operational context for a leg or waypoint. */
+export declare enum OperationalContext {
+    OPERATIONAL_CONTEXT_UNSPECIFIED = 0,
+    OPERATIONAL_CONTEXT_OPEN_SEA = 1,
+    OPERATIONAL_CONTEXT_COASTAL = 2,
+    OPERATIONAL_CONTEXT_ARCHIPELAGO = 3,
+    OPERATIONAL_CONTEXT_PORT_APPROACH = 4,
+    OPERATIONAL_CONTEXT_PORT_AREA = 5,
+    OPERATIONAL_CONTEXT_RIVER_WATERS = 6,
+    OPERATIONAL_CONTEXT_LOCK = 7,
+    UNRECOGNIZED = -1
+}
+export declare function operationalContextFromJSON(object: any): OperationalContext;
+export declare function operationalContextToJSON(object: OperationalContext): string;
+/** Categorisation of route challenges (used in structured risk). */
+export declare enum RouteChallengeType {
+    ROUTE_CHALLENGE_TYPE_UNSPECIFIED = 0,
+    ROUTE_CHALLENGE_TYPE_SHALLOW_WATER = 1,
+    ROUTE_CHALLENGE_TYPE_TRAFFIC_DENSITY = 2,
+    ROUTE_CHALLENGE_TYPE_WEATHER_HAZARD = 3,
+    ROUTE_CHALLENGE_TYPE_PIRACY_SECURITY = 4,
+    ROUTE_CHALLENGE_TYPE_REGULATORY_LIMIT = 5,
+    ROUTE_CHALLENGE_TYPE_TECHNICAL_LIMIT = 6,
+    ROUTE_CHALLENGE_TYPE_OTHER = 7,
+    UNRECOGNIZED = -1
+}
+export declare function routeChallengeTypeFromJSON(object: any): RouteChallengeType;
+export declare function routeChallengeTypeToJSON(object: RouteChallengeType): string;
+/** Hazard zone classification. */
+export declare enum HazardZoneType {
+    HAZARD_ZONE_TYPE_UNSPECIFIED = 0,
+    HAZARD_ZONE_TYPE_STATIC_NOGO = 1,
+    HAZARD_ZONE_TYPE_DYNAMIC_NOGO = 2,
+    HAZARD_ZONE_TYPE_TRAFFIC = 3,
+    HAZARD_ZONE_TYPE_WEATHER = 4,
+    HAZARD_ZONE_TYPE_ENVIRONMENTAL = 5,
+    UNRECOGNIZED = -1
+}
+export declare function hazardZoneTypeFromJSON(object: any): HazardZoneType;
+export declare function hazardZoneTypeToJSON(object: HazardZoneType): string;
+/** COLREG encounter situation for an annotated leg. */
+export declare enum ColregSituation {
+    COLREG_SITUATION_UNSPECIFIED = 0,
+    COLREG_SITUATION_OVERTAKING = 1,
+    COLREG_SITUATION_CROSSING_STBD = 2,
+    COLREG_SITUATION_CROSSING_PORT = 3,
+    COLREG_SITUATION_HEAD_ON = 4,
+    UNRECOGNIZED = -1
+}
+export declare function colregSituationFromJSON(object: any): ColregSituation;
+export declare function colregSituationToJSON(object: ColregSituation): string;
+/** Annotated traffic intensity for a leg. */
+export declare enum ColregTrafficIntensity {
+    COLREG_TRAFFIC_INTENSITY_UNSPECIFIED = 0,
+    COLREG_TRAFFIC_INTENSITY_NONE = 1,
+    COLREG_TRAFFIC_INTENSITY_LIGHT = 2,
+    COLREG_TRAFFIC_INTENSITY_MODERATE = 3,
+    COLREG_TRAFFIC_INTENSITY_HEAVY = 4,
+    UNRECOGNIZED = -1
+}
+export declare function colregTrafficIntensityFromJSON(object: any): ColregTrafficIntensity;
+export declare function colregTrafficIntensityToJSON(object: ColregTrafficIntensity): string;
+/** Geometry type for a leg between waypoints. */
+export declare enum GeometryType {
+    GEOMETRY_TYPE_UNSPECIFIED = 0,
+    GEOMETRY_TYPE_LOXODROME = 1,
+    GEOMETRY_TYPE_ORTHODROME = 2,
+    UNRECOGNIZED = -1
+}
+export declare function geometryTypeFromJSON(object: any): GeometryType;
+export declare function geometryTypeToJSON(object: GeometryType): string;
+/**
+ * Lifecycle status for the route artifact (authoring + quality).
+ * Execution-side state (vessel sailing, paused, completed) lives on
+ * keelson.VoyageStatus and is intentionally NOT duplicated here.
+ */
+export declare enum RouteStatus {
+    ROUTE_STATUS_UNSPECIFIED = 0,
+    ROUTE_STATUS_INITIAL = 1,
+    ROUTE_STATUS_PLANNED = 2,
+    ROUTE_STATUS_RECOMMENDED = 3,
+    ROUTE_STATUS_ACKNOWLEDGED = 4,
+    /** ROUTE_STATUS_TERMINATED - Route artifact retired / superseded. */
+    ROUTE_STATUS_TERMINATED = 6,
+    ROUTE_STATUS_ERRORS = 7,
+    ROUTE_STATUS_INCOMPLETE = 8,
+    ROUTE_STATUS_ROUTE_ISSUES = 9,
+    UNRECOGNIZED = -1
+}
+export declare function routeStatusFromJSON(object: any): RouteStatus;
+export declare function routeStatusToJSON(object: RouteStatus): string;
+/** Required action for an ActionPoint. */
+export declare enum ActionPointRequiredAction {
+    ACTION_POINT_REQUIRED_ACTION_UNSPECIFIED = 0,
+    ACTION_POINT_REQUIRED_ACTION_USER_DEFINED = 1,
+    ACTION_POINT_REQUIRED_ACTION_REPORT = 2,
+    /** ACTION_POINT_REQUIRED_ACTION_UKCM - Under-keel clearance monitoring */
+    ACTION_POINT_REQUIRED_ACTION_UKCM = 3,
+    ACTION_POINT_REQUIRED_ACTION_NOTE = 4,
+    ACTION_POINT_REQUIRED_ACTION_PILOT_BOARDING = 5,
+    ACTION_POINT_REQUIRED_ACTION_FUEL_SWITCH = 6,
+    ACTION_POINT_REQUIRED_ACTION_MODE_SWITCH = 7,
+    ACTION_POINT_REQUIRED_ACTION_INCREASE_LOOKOUT = 8,
+    UNRECOGNIZED = -1
+}
+export declare function actionPointRequiredActionFromJSON(object: any): ActionPointRequiredAction;
+export declare function actionPointRequiredActionToJSON(object: ActionPointRequiredAction): string;
+/**
+ * A reference to one specific edition of a route.
+ *
+ * A bare route_id names a LINEAGE, not a document: editions exist precisely so
+ * that routes change, so "the route with id X" is ambiguous the moment anyone
+ * bumps it. Anything that pins a route — a voyage, an execution sample — must
+ * say which edition it pinned, and carrying the pair as a type rather than as
+ * two loose fields is what stops the two drifting apart in a message that only
+ * remembered to update one of them.
+ *
+ * Resolution is defined in the protocol specification §6.3: the pair addresses
+ * `pubsub/route/{route_id}/edition/{route_edition_number}`. A reference whose
+ * edition cannot be resolved is dangling and must be surfaced, never silently
+ * resolved to `latest`.
+ */
+export interface RouteRef {
+    $type: "keelson.RouteRef";
+    routeId: string;
+    routeEditionNumber: number;
+}
+/**
+ * A circle: centre plus radius, in metres.
+ *
+ * Exists so that geometry can be a `oneof`. Modelled as parallel fields, a
+ * centre with no radius, a radius with no centre, and a circle that also
+ * carries a polygon are all representable — and a consumer meeting one has no
+ * rule for which to believe. Binding the two into a single message makes the
+ * incomplete states unrepresentable rather than merely discouraged.
+ */
+export interface CircleGeometry {
+    $type: "keelson.CircleGeometry";
+    centre: LocationFix | undefined;
+    radiusM: number;
+}
+/**
+ * Vendor- or model-specific data attached to any container. Each entry is
+ * scoped by manufacturer + name + version so multiple vendors can coexist on
+ * the same route without colliding.
+ *
+ * NOTE: the per-entry `payload` is a google.protobuf.Any — a deliberate,
+ * reviewed exception to the "no opaque escape hatch" guidance (#154), and the
+ * ONLY one left in this family (RouteChangeEvent.diff was the other; it was
+ * removed rather than granted the same exception, because it was convenience
+ * rather than a requirement of the interchange format). It is the
+ * vendor-extension mechanism for this RTZ 1.2 / S-421 standards-exchange
+ * format, which has to be able to carry data keelson does not model.
+ *
+ * The exception comes with two obligations, both load-bearing:
+ *
+ *  1. Producers SHOULD prefer the typed `attributes` map for simple key/values
+ *     and reserve Any for genuinely vendor-specific structured payloads.
+ *  2. A consumer that cannot resolve an entry's `type_url` MUST pass the entry
+ *     through unchanged rather than drop it. Extensions are the one part of a
+ *     Route that is opaque by design, so the only way a round-trip through a
+ *     keelson consumer can be lossless is if unknown entries survive it. An
+ *     editor that re-publishes a route it does not fully understand and
+ *     silently discards another vendor's extension has corrupted the artifact.
+ */
+export interface Extensions {
+    $type: "keelson.Extensions";
+    entries: Extensions_Entry[];
+}
+export interface Extensions_Entry {
+    $type: "keelson.Extensions.Entry";
+    /** Reverse-DNS or short vendor identifier (e.g. "se.rise", "kongsberg"). */
+    manufacturer: string;
+    /** Vendor-scoped extension name. */
+    name: string;
+    /** Extension version (semver or vendor-defined). */
+    version: string;
+    /** Strongly-typed payload. */
+    payload: Any | undefined;
+    /** Lightweight key/value attributes that don't justify a typed payload. */
+    attributes: {
+        [key: string]: string;
+    };
+}
+export interface Extensions_Entry_AttributesEntry {
+    $type: "keelson.Extensions.Entry.AttributesEntry";
+    key: string;
+    value: string;
+}
+export interface Route {
+    $type: "keelson.Route";
+    /** Schema version this Route conforms to. */
+    version: string;
+    /** Globally unique route identifier (UUID recommended). */
+    routeId: string;
+    /** Monotonically increasing edition number; bumped on any edit. */
+    routeEditionNumber: number;
+    /**
+     * RTZ / S-421 format version this Route is compatible with
+     * (e.g. "RTZ-1.2", "S-421-FC1.0").
+     */
+    routeFormatVersion: string;
+    /** Lifecycle status. */
+    status: RouteStatus;
+    /** Time the route was created and last modified. */
+    createdAt: Date | undefined;
+    modifiedAt: Date | undefined;
+    info: RouteInfo | undefined;
+    waypoints: Waypoints | undefined;
+    schedules: Schedules | undefined;
+    actionPoints: ActionPoints | undefined;
+    /** Dynamic hazards / no-go areas valid for this route. */
+    hazardZones: HazardZone[];
+    /** Structured challenges / risks identified during planning. */
+    challenges: RouteChallenge[];
+    /** Free-form notes or issues against the route as a whole. */
+    issues: RouteIssue[];
+    extensions: Extensions | undefined;
+}
+/**
+ * Route artifact metadata. Vessel identity, port codes, planned dep/arr times,
+ * and voyage_id intentionally live on keelson.Voyage instead of here, so a
+ * Route can be authored once and executed by multiple voyages.
+ */
+export interface RouteInfo {
+    $type: "keelson.RouteInfo";
+    /** Human-readable route name. */
+    name: string;
+    /** Author of the route (planner / system name). */
+    author: string;
+    /** Organisation owning the route. */
+    authorOrganization: string;
+    /** Validity window for this route (e.g. tidal window, weather window). */
+    validFrom: Date | undefined;
+    validTo: Date | undefined;
+    /**
+     * -- Vessel-class plan constraints ------------------------------------------
+     * Dimensions the route was authored against. These are constraints, not
+     * identity — the vessel actually executing the voyage may differ within
+     * these bounds. Vessel identity lives on keelson.Voyage.
+     * `optional` throughout: a plan authored without a beam constraint is not a
+     * plan for a vessel of zero beam. Proto3 implicit presence cannot tell the
+     * two apart, and 0.0 is the more dangerous reading of the pair.
+     */
+    vesselLoaM?: number | undefined;
+    /** Maximum beam */
+    vesselBeamM?: number | undefined;
+    /** Maximum draft the route was planned for */
+    vesselDraftM?: number | undefined;
+    /** Maximum height above waterline */
+    vesselAirDraftM?: number | undefined;
+    /**
+     * -- Operational limits -----------------------------------------------------
+     * Limits the route is valid under. Use `optional` so a zero value means
+     * "no limit applies" only when the field is set; an unset field means the
+     * limit is unknown / not specified.
+     */
+    maxRollDeg?: number | undefined;
+    maxWaveHeightM?: number | undefined;
+    maxWindSpeedMps?: number | undefined;
+    minSpeedKnots?: number | undefined;
+    maxSpeedKnots?: number | undefined;
+    /**
+     * Minimum visibility the route is valid above. `visibility_range_m` is
+     * published, so without this the measurement exists and the limit it should
+     * be checked against does not.
+     */
+    minVisibilityM?: number | undefined;
+    /**
+     * Gust limit, distinct from the mean-wind limit above. Gust is what governs
+     * small-craft operations: 12 m/s mean with 20 m/s gusts is a different
+     * proposition from a steady 12 m/s, and only the mean can be constrained
+     * today. Checked against the windowed `true_wind_speed_max_mps`.
+     */
+    maxWindGustMps?: number | undefined;
+    /**
+     * -- Optimization & autonomy ------------------------------------------------
+     * Free-form optimization method label (e.g. "fuel-min", "eta-min", "weather-routed").
+     */
+    optimizationMethod: string;
+    /** Target autonomy level this route is authored for. */
+    autonomyLevel: AutonomyLevel;
+    extensions: Extensions | undefined;
+}
+export interface Waypoints {
+    $type: "keelson.Waypoints";
+    /** Default values applied to any waypoint or leg that doesn't override them. */
+    defaults: DefaultWaypoint | undefined;
+    /** Ordered list of waypoints, in route order. */
+    waypoint: Waypoint[];
+    extensions: Extensions | undefined;
+}
+/**
+ * Default values for waypoint/leg fields. RTZ-aligned.
+ *
+ * The scalars are `optional` for the same reason as their `Waypoint`
+ * counterparts, one level up: without presence there is no way to say "this
+ * route sets no default speed" as distinct from "this route defaults to
+ * zero", and a consumer merging defaults into a waypoint cannot tell which
+ * it was handed.
+ */
+export interface DefaultWaypoint {
+    $type: "keelson.DefaultWaypoint";
+    leg: Leg | undefined;
+    radiusM?: number | undefined;
+    plannedSogKnots?: number | undefined;
+}
+export interface Waypoint {
+    $type: "keelson.Waypoint";
+    /**
+     * Stable waypoint identifier. §6.2 rests its whole addressing rule on this
+     * field: array indices mean a different waypoint after an edit, so anything
+     * referring to a waypoint MUST carry the id.
+     *
+     * `string`, matching every other id in this family (Schedule, ActionPoint,
+     * HazardZone, RouteChallenge, RouteIssue). The trade-off is RTZ 1.2, where
+     * waypoint ids are integers: an importer stringifies and an exporter must
+     * parse back, and a non-numeric id is expressible here but not
+     * RTZ-exportable. Chosen deliberately — one id type across the family beats
+     * fidelity to a format keelson only interoperates with at the edges.
+     */
+    id: string;
+    /** Revision counter for this specific waypoint. */
+    revision: number;
+    /** Human-readable name (e.g. "WP-007 East of Hanö"). */
+    name: string;
+    /**
+     * WGS-84 position. `Coordinate`, not `LocationFix`: a planned waypoint is
+     * a referent, not a measurement, and has no use for a covariance matrix or
+     * fix quality. See protocol-specification.md §2.2.1 and §6.8.
+     */
+    position: Coordinate | undefined;
+    /**
+     * Planned speed over ground when leaving this waypoint. `optional` because
+     * `Waypoints.defaults` backs this field: without presence, "no override,
+     * use the default" and "hold zero speed here" are the same bytes, and 0.0
+     * is the more dangerous reading of the pair.
+     */
+    plannedSogKnots?: number | undefined;
+    /**
+     * Turn radius for fly-by, in metres. `optional` for the same reason —
+     * `DefaultWaypoint.radius_m` is the fallback when this is unset.
+     */
+    radiusM?: number | undefined;
+    /**
+     * Maximum rate of turn during the turn, degrees per second. Not backed by
+     * `defaults`, but 0 is still not a rate anyone means to command.
+     */
+    rateOfTurnDegps?: number | undefined;
+    /** Distance before the turn at which wheel-over should be ordered, metres. */
+    wheelOverDistanceM?: number | undefined;
+    /**
+     * If true, the waypoint is locked and may not be edited by autonomous
+     * re-routing.
+     */
+    lock: boolean;
+    /** Operational context for this waypoint (open sea, port approach, lock, ...). */
+    operationalContext: OperationalContext;
+    /** Outgoing leg from this waypoint to the next. The last waypoint has none. */
+    leg: Leg | undefined;
+    /** Free-form notes attached to this waypoint. */
+    note: string;
+    extensions: Extensions | undefined;
+}
+export interface Leg {
+    $type: "keelson.Leg";
+    /**
+     * Cross-track distance (XTD) limits and monitoring thresholds, in metres.
+     * `optional` so producers can distinguish "no XTD limit" (unset) from
+     * "zero XTD limit" (set to 0).
+     */
+    xtdPortM?: number | undefined;
+    xtdStarboardM?: number | undefined;
+    xtdMonitoringPortM?: number | undefined;
+    xtdMonitoringStarboardM?: number | undefined;
+    /**
+     * Safety contour (depth in metres below chart datum) below which the route
+     * is considered unsafe.
+     */
+    safetyContourM?: number | undefined;
+    /** Minimum allowed depth on this leg, in metres. */
+    safetyDepthM?: number | undefined;
+    /** Static under-keel clearance, in metres. */
+    ukcStaticM?: number | undefined;
+    /** Dynamic under-keel clearance margin, in metres. */
+    ukcDynamicM?: number | undefined;
+    /**
+     * Planned draughts for this leg. `optional` for the same reason as the UKC
+     * margins above: a leg with no planned draught is not a leg planned for zero
+     * draught, and under-keel arithmetic is the last place to guess.
+     */
+    draughtBowM?: number | undefined;
+    draughtSternM?: number | undefined;
+    draughtMeanM?: number | undefined;
+    /** Geometry type along this leg. */
+    geometryType: GeometryType;
+    /**
+     * Speed envelope — Speed Over Ground (knots). `optional` so an open-ended
+     * envelope is expressible: unset minimum means "no lower bound", which is
+     * distinct from a commanded minimum of 0 kn (i.e. stop permitted).
+     */
+    sogMinKnots?: number | undefined;
+    sogMaxKnots?: number | undefined;
+    /** Speed envelope — Speed Through Water (knots). Same reading as above. */
+    stwMinKnots?: number | undefined;
+    stwMaxKnots?: number | undefined;
+    /**
+     * Dimensional limits for the leg (e.g. bridge clearances, lock dimensions).
+     * `optional` so unset means "no limit specified".
+     */
+    draughtMaxM?: number | undefined;
+    airDraftMaxM?: number | undefined;
+    beamMaxM?: number | undefined;
+    lengthMaxM?: number | undefined;
+    /** Free-text reporting / handover text for this leg. */
+    report: string;
+    /** Free-form notes. */
+    note: string;
+    /** COLREG annotations. */
+    colregSituation: ColregSituation;
+    colregTrafficIntensity: ColregTrafficIntensity;
+    extensions: Extensions | undefined;
+}
+export interface Schedules {
+    $type: "keelson.Schedules";
+    /** Multiple schedules can coexist (e.g. "manual", "weather-optimized"). */
+    schedule: Schedule[];
+    extensions: Extensions | undefined;
+}
+export interface Schedule {
+    $type: "keelson.Schedule";
+    /** Schedule identifier (unique within the route). */
+    id: string;
+    /** Free-text name. */
+    name: string;
+    origin: Schedule_Origin;
+    /** Ordered list of schedule entries, one per waypoint. */
+    element: ScheduleElement[];
+    extensions: Extensions | undefined;
+}
+/** Whether this schedule was authored manually or computed. */
+export declare enum Schedule_Origin {
+    ORIGIN_UNSPECIFIED = 0,
+    ORIGIN_MANUAL = 1,
+    ORIGIN_CALCULATED = 2,
+    UNRECOGNIZED = -1
+}
+export declare function schedule_OriginFromJSON(object: any): Schedule_Origin;
+export declare function schedule_OriginToJSON(object: Schedule_Origin): string;
+export interface ScheduleElement {
+    $type: "keelson.ScheduleElement";
+    /** ID of the waypoint this entry refers to. */
+    waypointId: string;
+    /** Estimated time of arrival / departure with allowed windows. */
+    eta: Date | undefined;
+    etaWindowStart: Date | undefined;
+    etaWindowEnd: Date | undefined;
+    etd: Date | undefined;
+    etdWindowStart: Date | undefined;
+    etdWindowEnd: Date | undefined;
+    /** Planned duration of stay at this waypoint (port, anchorage, ...). */
+    stay: Duration | undefined;
+    /** -- Environmental forecast for this leg ------------------------------------ */
+    windSpeedMps: number;
+    windDirectionDeg: number;
+    currentSpeedMps: number;
+    currentDirectionDeg: number;
+    waveHeightM: number;
+    wavePeriodS: number;
+    waveDirectionDeg: number;
+    /** -- Energy / propulsion plan ---------------------------------------------- */
+    plannedRpm: number;
+    plannedPropellerPitchPct: number;
+    plannedFuelKg: number;
+    /** Fuel savings versus a reference plan, in kilograms (negative = increase). */
+    fuelSavingVsReferenceKg: number;
+    extensions: Extensions | undefined;
+}
+export interface ActionPoints {
+    $type: "keelson.ActionPoints";
+    actionPoint: ActionPoint[];
+    extensions: Extensions | undefined;
+}
+export interface ActionPoint {
+    $type: "keelson.ActionPoint";
+    /** Stable action-point identifier. */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    circle?: CircleGeometry | undefined;
+    areaGeojson?: GeoJSON | undefined;
+    /**
+     * Lead time before crossing the geometry at which the action should be
+     * triggered (e.g. 5 minutes before pilot boarding ground).
+     */
+    timeToAct: Duration | undefined;
+    /** Required action. */
+    requiredAction: ActionPointRequiredAction;
+    /**
+     * Free-form action description (always required when required_action is
+     * USER_DEFINED; otherwise supplements the enum).
+     */
+    description: string;
+    extensions: Extensions | undefined;
+}
+export interface HazardZone {
+    $type: "keelson.HazardZone";
+    /** Stable hazard identifier. */
+    id: string;
+    type: HazardZoneType;
+    /** Hazard severity. */
+    severity: SeverityLevel;
+    /** Free-text description. */
+    description: string;
+    circle?: CircleGeometry | undefined;
+    polygonGeojson?: GeoJSON | undefined;
+    /** Validity window for the hazard. */
+    validFrom: Date | undefined;
+    validTo: Date | undefined;
+    extensions: Extensions | undefined;
+}
+export interface RouteChallenge {
+    $type: "keelson.RouteChallenge";
+    id: string;
+    type: RouteChallengeType;
+    severity: SeverityLevel;
+    description: string;
+    /** Waypoint IDs the challenge applies to (empty = whole route). */
+    waypointIds: string[];
+    extensions: Extensions | undefined;
+}
+export interface RouteIssue {
+    $type: "keelson.RouteIssue";
+    id: string;
+    severity: SeverityLevel;
+    description: string;
+    raisedAt: Date | undefined;
+    raisedBy: string;
+    extensions: Extensions | undefined;
+}
+/**
+ * The signatures attesting to one specific route edition, published on the
+ * `route_signature` subject at
+ *   route_signature/{route_id}/edition/{N}
+ * alongside the edition they attest to, never inside it.
+ *
+ * WHAT IS SIGNED — see protocol-specification.md §6.3.1 for the normative rule.
+ * The signing input is exactly the `Envelope.payload` bytes stored at
+ * `route/{route_id}/edition/{N}`: the serialized keelson.Route, byte for byte
+ * as the publisher wrote it. Verification is a `get` on that key followed by a
+ * signature check over the returned bytes verbatim — no re-serialization, no
+ * field reordering, no canonicalization step to disagree about.
+ *
+ * This works only because §6.3 makes an edition key immutable once written. An
+ * edition is not a mutable document that happens to have a version number; it
+ * is a fixed artifact, and that is what makes it signable at all. If editions
+ * ever became rewritable, this scheme would have to be revisited — a signature
+ * over bytes that can change underneath it attests to nothing.
+ *
+ * Separating the two also means signing does not bump the edition: attesting
+ * to a plan is not editing it, and a signature arriving late (a second master
+ * countersigning hours later) adds an entry here without disturbing the
+ * artifact or the change log.
+ */
+export interface RouteSignatures {
+    $type: "keelson.RouteSignatures";
+    /** The edition these signatures attest to. */
+    routeRef: RouteRef | undefined;
+    /** One entry per signer. Order is not significant. */
+    signatures: RouteSignature[];
+    extensions: Extensions | undefined;
+}
+export interface RouteSignature {
+    $type: "keelson.RouteSignature";
+    /** Free-form signer identifier (e.g. user id, system id). */
+    signerId: string;
+    /** Signer role (e.g. "master", "planner", "shore-control"). */
+    signerRole: string;
+    /** Signing algorithm (e.g. "ed25519", "ecdsa-p256-sha256"). */
+    algorithm: string;
+    /** Raw signature bytes. */
+    signature: Uint8Array;
+    /** Time of signing. */
+    signedAt: Date | undefined;
+    /** Reference to the public key used to verify (key id, URL, fingerprint). */
+    keyReference: string;
+    extensions: Extensions | undefined;
+}
+/**
+ * Standalone, structured payload for the `route_status` subject. Replaces the
+ * previous TimestampedString mapping so subscribers can act on the standard
+ * RouteStatus enum without parsing free-form text.
+ */
+export interface RouteStatusUpdate {
+    $type: "keelson.RouteStatusUpdate";
+    timestamp: Date | undefined;
+    routeId: string;
+    routeEditionNumber: number;
+    status: RouteStatus;
+    changedBy: string;
+    note: string;
+}
+export declare const RouteRef: MessageFns<RouteRef, "keelson.RouteRef">;
+export declare const CircleGeometry: MessageFns<CircleGeometry, "keelson.CircleGeometry">;
+export declare const Extensions: MessageFns<Extensions, "keelson.Extensions">;
+export declare const Extensions_Entry: MessageFns<Extensions_Entry, "keelson.Extensions.Entry">;
+export declare const Extensions_Entry_AttributesEntry: MessageFns<Extensions_Entry_AttributesEntry, "keelson.Extensions.Entry.AttributesEntry">;
+export declare const Route: MessageFns<Route, "keelson.Route">;
+export declare const RouteInfo: MessageFns<RouteInfo, "keelson.RouteInfo">;
+export declare const Waypoints: MessageFns<Waypoints, "keelson.Waypoints">;
+export declare const DefaultWaypoint: MessageFns<DefaultWaypoint, "keelson.DefaultWaypoint">;
+export declare const Waypoint: MessageFns<Waypoint, "keelson.Waypoint">;
+export declare const Leg: MessageFns<Leg, "keelson.Leg">;
+export declare const Schedules: MessageFns<Schedules, "keelson.Schedules">;
+export declare const Schedule: MessageFns<Schedule, "keelson.Schedule">;
+export declare const ScheduleElement: MessageFns<ScheduleElement, "keelson.ScheduleElement">;
+export declare const ActionPoints: MessageFns<ActionPoints, "keelson.ActionPoints">;
+export declare const ActionPoint: MessageFns<ActionPoint, "keelson.ActionPoint">;
+export declare const HazardZone: MessageFns<HazardZone, "keelson.HazardZone">;
+export declare const RouteChallenge: MessageFns<RouteChallenge, "keelson.RouteChallenge">;
+export declare const RouteIssue: MessageFns<RouteIssue, "keelson.RouteIssue">;
+export declare const RouteSignatures: MessageFns<RouteSignatures, "keelson.RouteSignatures">;
+export declare const RouteSignature: MessageFns<RouteSignature, "keelson.RouteSignature">;
+export declare const RouteStatusUpdate: MessageFns<RouteStatusUpdate, "keelson.RouteStatusUpdate">;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P> | "$type">]: never;
+};
+interface MessageFns<T, V extends string> {
+    readonly $type: V;
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};