@rise-maritime/keelson-js 0.6.0-alpha.282.dev.2 → 0.6.0-alpha.307.dev.2

package/dist/payloads/NavigationRisk.d.ts

@@ -0,0 +1,341 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * One navigation risk assessment of own ship, at one instant.
+ *
+ * The assessment is a set of independent dimensions, each of which is either measured — with a
+ * risk in [0, 1] and the provenance of the evidence it rests on — or NOT MEASURABLE, with the
+ * reason. The second case is why this is a message and not a handful of floats: a missing risk
+ * read as zero is the most dangerous thing a consumer of this subject could do.
+ */
+export interface NavigationRisk {
+    $type: "keelson.NavigationRisk";
+    /** The instant assessed: the end of the interval the inputs were aggregated over. */
+    timestamp: Date | undefined;
+    /** When the assessment was computed. */
+    evaluatedAt: Date | undefined;
+    model: NavigationRisk_Model | undefined;
+    combined: NavigationRisk_CombinedRisk | undefined;
+    gates: NavigationRisk_Gates | undefined;
+    dimensions: NavigationRisk_DimensionRisk[];
+    targets: NavigationRisk_TargetRisk[];
+    inputs: NavigationRisk_Inputs | undefined;
+}
+/** NOT ordinal: LEVEL_NOT_ASSESSED sorts after LEVEL_HIGH. Compare by name, never with < or >. */
+export declare enum NavigationRisk_Level {
+    LEVEL_UNSPECIFIED = 0,
+    LEVEL_LOW = 1,
+    LEVEL_MEDIUM = 2,
+    LEVEL_HIGH = 3,
+    LEVEL_NOT_ASSESSED = 4,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_LevelFromJSON(object: any): NavigationRisk_Level;
+export declare function navigationRisk_LevelToJSON(object: NavigationRisk_Level): string;
+export declare enum NavigationRisk_Dimension {
+    DIMENSION_UNSPECIFIED = 0,
+    /** DIMENSION_COLLISION - §4.1 */
+    DIMENSION_COLLISION = 1,
+    /** DIMENSION_GROUNDING - §4.3 */
+    DIMENSION_GROUNDING = 2,
+    /** DIMENSION_MANOEUVRE - §4.5 manoeuvring margin */
+    DIMENSION_MANOEUVRE = 3,
+    /** DIMENSION_FAIRWAY - §4.6 reachable fairway */
+    DIMENSION_FAIRWAY = 4,
+    /** DIMENSION_DETECTABILITY - §4.4 */
+    DIMENSION_DETECTABILITY = 5,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_DimensionFromJSON(object: any): NavigationRisk_Dimension;
+export declare function navigationRisk_DimensionToJSON(object: NavigationRisk_Dimension): string;
+export declare enum NavigationRisk_Provenance {
+    PROVENANCE_UNSPECIFIED = 0,
+    /** PROVENANCE_MEASURED - own ship's own sensors */
+    PROVENANCE_MEASURED = 1,
+    /** PROVENANCE_AIS - a third party's report */
+    PROVENANCE_AIS = 2,
+    /** PROVENANCE_DERIVED - computed from other fields present */
+    PROVENANCE_DERIVED = 3,
+    /** PROVENANCE_SYNTHESISED - a model standing in for this vessel */
+    PROVENANCE_SYNTHESISED = 4,
+    /** PROVENANCE_ASSUMED - a documented constant */
+    PROVENANCE_ASSUMED = 5,
+    /** PROVENANCE_ABSENT - nothing — the dimension is not measurable */
+    PROVENANCE_ABSENT = 6,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_ProvenanceFromJSON(object: any): NavigationRisk_Provenance;
+export declare function navigationRisk_ProvenanceToJSON(object: NavigationRisk_Provenance): string;
+export declare enum NavigationRisk_OmissionReason {
+    OMISSION_REASON_UNSPECIFIED = 0,
+    OMISSION_REASON_CAPACITY = 1,
+    OMISSION_REASON_STALE = 2,
+    /** OMISSION_REASON_OUT_OF_RANGE - counted in Inputs.targets_out_of_range, not listed */
+    OMISSION_REASON_OUT_OF_RANGE = 3,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_OmissionReasonFromJSON(object: any): NavigationRisk_OmissionReason;
+export declare function navigationRisk_OmissionReasonToJSON(object: NavigationRisk_OmissionReason): string;
+export declare enum NavigationRisk_SurveillanceState {
+    SURVEILLANCE_STATE_UNSPECIFIED = 0,
+    SURVEILLANCE_STATE_NO_FEED = 1,
+    SURVEILLANCE_STATE_SILENT = 2,
+    SURVEILLANCE_STATE_PARTIAL = 3,
+    SURVEILLANCE_STATE_LIVE_EMPTY = 4,
+    SURVEILLANCE_STATE_LIVE_TARGETS = 5,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_SurveillanceStateFromJSON(object: any): NavigationRisk_SurveillanceState;
+export declare function navigationRisk_SurveillanceStateToJSON(object: NavigationRisk_SurveillanceState): string;
+export declare enum NavigationRisk_FeedHealthState {
+    FEED_HEALTH_STATE_UNSPECIFIED = 0,
+    FEED_HEALTH_STATE_LIVE = 1,
+    FEED_HEALTH_STATE_SILENT = 2,
+    FEED_HEALTH_STATE_NEVER_HEARD = 3,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_FeedHealthStateFromJSON(object: any): NavigationRisk_FeedHealthState;
+export declare function navigationRisk_FeedHealthStateToJSON(object: NavigationRisk_FeedHealthState): string;
+export declare enum NavigationRisk_FeedState {
+    FEED_STATE_UNSPECIFIED = 0,
+    FEED_STATE_LIVE = 1,
+    FEED_STATE_SILENT = 2,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_FeedStateFromJSON(object: any): NavigationRisk_FeedState;
+export declare function navigationRisk_FeedStateToJSON(object: NavigationRisk_FeedState): string;
+export declare enum NavigationRisk_ChartState {
+    CHART_STATE_UNSPECIFIED = 0,
+    CHART_STATE_ABSENT = 1,
+    CHART_STATE_CONNECTING = 2,
+    CHART_STATE_CONNECTED = 3,
+    CHART_STATE_FAILED = 4,
+    UNRECOGNIZED = -1
+}
+export declare function navigationRisk_ChartStateFromJSON(object: any): NavigationRisk_ChartState;
+export declare function navigationRisk_ChartStateToJSON(object: NavigationRisk_ChartState): string;
+export interface NavigationRisk_Model {
+    $type: "keelson.NavigationRisk.Model";
+    /** e.g. "navrisk" */
+    package: string;
+    version: string;
+}
+/** Method §6.2: weighted noisy-OR over the measurable dimensions. */
+export interface NavigationRisk_CombinedRisk {
+    $type: "keelson.NavigationRisk.CombinedRisk";
+    riskCombined: number;
+    /** Weighted share of the dimensions that were measurable. Never read risk_combined without it. */
+    scoredCoverage: number;
+    /** The highest risk_combined attainable with the dimensions that were measurable. */
+    ceiling: number;
+    /** risk_combined / ceiling — what the level is banded on. */
+    riskFraction: number;
+    level: NavigationRisk_Level;
+    /** True when the level was held below HIGH because coverage was too low to earn it. */
+    levelCoverageCapped: boolean;
+}
+/** Method §6.4: per-dimension acceptance limits, applied only where a dimension was measurable. */
+export interface NavigationRisk_Gates {
+    $type: "keelson.NavigationRisk.Gates";
+    applied: number;
+    notApplied: NavigationRisk_Dimension[];
+    /** All applied gates passed. False when none could be applied: nothing measured is not a pass. */
+    pass: boolean;
+}
+export interface NavigationRisk_DimensionRisk {
+    $type: "keelson.NavigationRisk.DimensionRisk";
+    dimension: NavigationRisk_Dimension;
+    measurable: boolean;
+    /** Present only when measurable. Absent is NOT zero. */
+    risk?: number | undefined;
+    /** Method §2.5: the weakest provenance of any input the figure rests on. */
+    provenance: NavigationRisk_Provenance;
+    /** Why not measurable, or what was synthesised. */
+    note: string;
+    evaluatedAt: Date | undefined;
+    /** A result from a slower loop (the chart dimensions) older than the producer accepts. */
+    stale: boolean;
+}
+/** Method §4.1 per target. */
+export interface NavigationRisk_TargetRisk {
+    $type: "keelson.NavigationRisk.TargetRisk";
+    targetId: string;
+    measurable: boolean;
+    risk?: number | undefined;
+    /** A particular (length, beam, draught) was not transmitted and a documented bound stood in. */
+    synthesised: boolean;
+    dcpaM?: number | undefined;
+    tcpaS?: number | undefined;
+    rangeM?: number | undefined;
+    note: string;
+    presentSeparation: NavigationRisk_PresentSeparation | undefined;
+    encounterContext: NavigationRisk_EncounterContext | undefined;
+    /**
+     * NAV-005: consequence for the more vulnerable vessel (scored), and the
+     * pre-NAV-005 ULCC-normalised figure (not scored), for comparison.
+     */
+    consequence?: number | undefined;
+    consequenceLegacy?: number | undefined;
+    /** outside the studied envelope, if any */
+    applicability: string[];
+    /** The target's MMSI; 0 when unknown. Lets a consumer join a target without parsing target_id. */
+    mmsi: number;
+    /**
+     * The traffic feed whose reports this assessment used, as "entity_id/source_id". A target heard
+     * on two feeds is assessed from one of them only — two reporters interleaved into one track
+     * produce a false speed.
+     */
+    feed: string;
+    /**
+     * The producer's band for this target's risk, on the same scale as CombinedRisk.level. Absent
+     * when not measurable. The producer owns the banding, so no consumer invents thresholds.
+     */
+    level?: NavigationRisk_Level | undefined;
+}
+/**
+ * Present geometry is independent of TargetRisk.measurable (future CPA).
+ * Nullable checks distinguish unknown from false; no accident probability.
+ */
+export interface NavigationRisk_PresentSeparation {
+    $type: "keelson.NavigationRisk.PresentSeparation";
+    rangeM?: number | undefined;
+    domainRadiusM?: number | undefined;
+    domainIntrusion?: boolean | undefined;
+    intrusionFraction?: number | undefined;
+    hullClearanceM?: number | undefined;
+    hullContact?: boolean | undefined;
+    /** modelled, not a measured safe-distance limit */
+    domainBasis: string;
+    /** supplied_clearance or unavailable */
+    hullBasis: string;
+    note: string;
+    /**
+     * Estimated bound from range and hull diagonals; valid for any position
+     * reference on or inside each hull. Not measured clearance.
+     */
+    hullClearanceLowerM?: number | undefined;
+    hullClearanceUpperM?: number | undefined;
+    /** false: cannot be excluded, not contact */
+    hullContactExcluded?: boolean | undefined;
+    /** range_minus_hull_diagonals or unavailable */
+    clearanceBoundBasis: string;
+}
+/**
+ * Where the encounter is, from the charts (NAV-002). A diagnostic, never a
+ * score input, and not hull clearance: charts hold no vessels. Only derived
+ * flags leave the chart — no geometry or feature names (charts may be restricted).
+ */
+export interface NavigationRisk_EncounterContext {
+    $type: "keelson.NavigationRisk.EncounterContext";
+    ownShip: NavigationRisk_ChartedSetting | undefined;
+    target: NavigationRisk_ChartedSetting | undefined;
+}
+/** Unset fields are unknown (no coverage, layer absent, query failed or not assessed). */
+export interface NavigationRisk_ChartedSetting {
+    $type: "keelson.NavigationRisk.ChartedSetting";
+    covered?: boolean | undefined;
+    inFairway?: boolean | undefined;
+    inTssLane?: boolean | undefined;
+    inTssZone?: boolean | undefined;
+    inHarbour?: boolean | undefined;
+    inAnchorage?: boolean | undefined;
+    /** nearest berth/pontoon/mooring within berth_radius_m */
+    berthDistanceM?: number | undefined;
+    berthRadiusM?: number | undefined;
+    chartScale?: number | undefined;
+    note: string;
+}
+/** Input health, so a reader can tell "nothing nearby" from "no feed". */
+export interface NavigationRisk_Inputs {
+    $type: "keelson.NavigationRisk.Inputs";
+    targetsTracked: number;
+    aisFeed: NavigationRisk_FeedState;
+    chart: NavigationRisk_ChartState;
+    resampleS: number;
+    /** NAV-003: selection is by hazard priority; every in-range candidate not assessed is listed. */
+    targetsCandidate: number;
+    targetCapacity: number;
+    /** targets_candidate > target_capacity */
+    overloaded: boolean;
+    omittedTargets: NavigationRisk_OmittedTarget[];
+    surveillance: NavigationRisk_Surveillance | undefined;
+    /** undecodable or unusable, since start */
+    rejectedMessages?: number | undefined;
+    /**
+     * NAV-004: seconds between the interval assessed and the one just closed; beyond the
+     * producer's limit the record is LEVEL_NOT_ASSESSED.
+     */
+    ownFixAgeS?: number | undefined;
+    /** target SOG smoothing: 8 rows, in seconds */
+    smoothingSpanS?: number | undefined;
+    /**
+     * 13 is left for the own ship's turn envelope (navrisk NAV-006), proposed separately.
+     * Targets heard beyond the producer's range limit, counted and NOT listed in omitted_targets.
+     * A shore AIS feed carries thousands of vessels; listing each would make every record huge.
+     */
+    targetsOutOfRange: number;
+}
+/**
+ * A target heard but not assessed: CAPACITY, or STALE within range. Out-of-range targets are
+ * counted in Inputs.targets_out_of_range instead. For CAPACITY the ranking proxy is given; it
+ * is an ordering aid (flat-earth, two-fix velocity), not a published CPA.
+ */
+export interface NavigationRisk_OmittedTarget {
+    $type: "keelson.NavigationRisk.OmittedTarget";
+    targetId: string;
+    mmsi: number;
+    reason: NavigationRisk_OmissionReason;
+    reports: number;
+    rangeM?: number | undefined;
+    dcpaM?: number | undefined;
+    tcpaS?: number | undefined;
+}
+/**
+ * What the traffic feeds can say. LIVE_EMPTY is not clear water: AIS observes
+ * transponder-carrying vessels only (scope).
+ */
+export interface NavigationRisk_Surveillance {
+    $type: "keelson.NavigationRisk.Surveillance";
+    state: NavigationRisk_SurveillanceState;
+    feeds: NavigationRisk_FeedHealth[];
+    scope: string;
+}
+export interface NavigationRisk_FeedHealth {
+    $type: "keelson.NavigationRisk.FeedHealth";
+    /** entity/source */
+    feed: string;
+    state: NavigationRisk_FeedHealthState;
+    lastMessageAgeS?: number | undefined;
+}
+export declare const NavigationRisk: MessageFns<NavigationRisk, "keelson.NavigationRisk">;
+export declare const NavigationRisk_Model: MessageFns<NavigationRisk_Model, "keelson.NavigationRisk.Model">;
+export declare const NavigationRisk_CombinedRisk: MessageFns<NavigationRisk_CombinedRisk, "keelson.NavigationRisk.CombinedRisk">;
+export declare const NavigationRisk_Gates: MessageFns<NavigationRisk_Gates, "keelson.NavigationRisk.Gates">;
+export declare const NavigationRisk_DimensionRisk: MessageFns<NavigationRisk_DimensionRisk, "keelson.NavigationRisk.DimensionRisk">;
+export declare const NavigationRisk_TargetRisk: MessageFns<NavigationRisk_TargetRisk, "keelson.NavigationRisk.TargetRisk">;
+export declare const NavigationRisk_PresentSeparation: MessageFns<NavigationRisk_PresentSeparation, "keelson.NavigationRisk.PresentSeparation">;
+export declare const NavigationRisk_EncounterContext: MessageFns<NavigationRisk_EncounterContext, "keelson.NavigationRisk.EncounterContext">;
+export declare const NavigationRisk_ChartedSetting: MessageFns<NavigationRisk_ChartedSetting, "keelson.NavigationRisk.ChartedSetting">;
+export declare const NavigationRisk_Inputs: MessageFns<NavigationRisk_Inputs, "keelson.NavigationRisk.Inputs">;
+export declare const NavigationRisk_OmittedTarget: MessageFns<NavigationRisk_OmittedTarget, "keelson.NavigationRisk.OmittedTarget">;
+export declare const NavigationRisk_Surveillance: MessageFns<NavigationRisk_Surveillance, "keelson.NavigationRisk.Surveillance">;
+export declare const NavigationRisk_FeedHealth: MessageFns<NavigationRisk_FeedHealth, "keelson.NavigationRisk.FeedHealth">;
+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 {};