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

package/dist/interfaces/NavigationState.d.ts

@@ -0,0 +1,132 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { OperationalAuthority_AuthorityLevel } from "./OperationalAuthority";
+import { RouteRef } from "./Route";
+export declare const protobufPackage = "keelson";
+/**
+ * What the vessel's navigation function is doing right now, stated by the process doing it.
+ *
+ * Not a lock and not a grant. command_authority says who holds the conn, operational_authority
+ * says the most the vessel may claim, and this says what navigation made of both. A consumer
+ * deciding whether to act on the vessel reads those, never this.
+ */
+export interface NavigationState {
+    timestamp: Date | undefined;
+    mode: NavigationState_Mode;
+    subMode: NavigationState_SubMode;
+    /** The voyage being monitored or sailed. Absent in MODE_IDLE. */
+    voyageId?: string | undefined;
+    /** The route edition in force. Absent when no edition is resolved; never `latest`. */
+    routeRef?: RouteRef | undefined;
+    /** The leg being sailed, named by the waypoint it leaves (RouteExecution convention). */
+    currentLegFromWaypointId?: string | undefined;
+    /**
+     * The operational_authority level this process is acting under. UNKNOWN when it has heard
+     * none, which is non-authorising exactly as OperationalAuthority defines it.
+     */
+    authorityLevelInForce: OperationalAuthority_AuthorityLevel;
+    /** True only while this process holds a live command_authority lease, judged on its own clock. */
+    connHeld: boolean;
+    /** Why the process is in this mode. For operators and logs; consumers MUST NOT parse it. */
+    reason: string;
+    /** Subjects this process needs and currently lacks or holds stale, e.g. "location_fix". */
+    degradedInputs: string[];
+    /**
+     * The guidance order in force: what this process has been told to steer by, whether or not it
+     * holds the conn to do it. Absent when it has no voyage. Set through navigation_control/v1.
+     */
+    guidanceOrder?: GuidanceOrder | undefined;
+}
+export declare enum NavigationState_Mode {
+    MODE_UNSPECIFIED = 0,
+    /** MODE_IDLE - No active voyage, or none this process can resolve. */
+    MODE_IDLE = 1,
+    /** MODE_READY - A voyage is active and monitored. Not holding the conn, commanding nothing. */
+    MODE_READY = 2,
+    /** MODE_UNDERWAY - Holding the conn and commanding the vessel along the voyage. */
+    MODE_UNDERWAY = 3,
+    /**
+     * MODE_FALLBACK - Lost something it needs to navigate (conn, authority, fresh ownship state) and has
+     * commanded its declared safe state. `reason` and `degraded_inputs` say what.
+     */
+    MODE_FALLBACK = 4,
+    /** MODE_ARRIVED - Reached the final waypoint of the active voyage. */
+    MODE_ARRIVED = 5,
+    /** MODE_ENDED - The voyage was completed or aborted; conn released. */
+    MODE_ENDED = 6,
+    UNRECOGNIZED = -1
+}
+export declare function navigationState_ModeFromJSON(object: any): NavigationState_Mode;
+export declare function navigationState_ModeToJSON(object: NavigationState_Mode): string;
+/** Refines MODE_UNDERWAY; UNSPECIFIED in every other mode. */
+export declare enum NavigationState_SubMode {
+    SUB_MODE_UNSPECIFIED = 0,
+    /** SUB_MODE_TRACK - following the planned track */
+    SUB_MODE_TRACK = 1,
+    /** SUB_MODE_AVOIDING - executing accepted collision-avoidance advice */
+    SUB_MODE_AVOIDING = 2,
+    /** SUB_MODE_HOLDING - speed zero or loitering, waiting on a condition */
+    SUB_MODE_HOLDING = 3,
+    /** SUB_MODE_REROUTING - awaiting a new route edition */
+    SUB_MODE_REROUTING = 4,
+    /** SUB_MODE_STEERING - holding an ordered course or heading, off the track (GuidanceOrder) */
+    SUB_MODE_STEERING = 5,
+    UNRECOGNIZED = -1
+}
+export declare function navigationState_SubModeFromJSON(object: any): NavigationState_SubMode;
+export declare function navigationState_SubModeToJSON(object: NavigationState_SubMode): string;
+/**
+ * How a navigation process is ordered to steer while a voyage is active. The one type used both to
+ * give the order (navigation_control/v1 set_guidance_order, load_route) and to report the order in
+ * force (NavigationState.guidance_order), so what was asked and what is held read alike.
+ *
+ * The frame is the field, as in vehicle_navigation/v1's SteeringOrder, so an order cannot name one
+ * frame and carry a value meant for another. Course over ground and heading are different
+ * instructions: in any current they differ by the drift angle.
+ */
+export interface GuidanceOrder {
+    track?: GuidanceOrder_Track | undefined;
+    /** Make good this course, degrees true, [0, 360). */
+    courseOverGroundDeg?: number | undefined;
+    /** Point this way, degrees true, [0, 360). */
+    headingDeg?: number | undefined;
+    hold?: GuidanceOrder_Hold | undefined;
+    /**
+     * Speed through the water to keep, in knots. Absent: the planned speed of the current leg for
+     * `track`, the speed she has for a course or heading. Ignored by `hold`.
+     */
+    speedKnots?: number | undefined;
+}
+/** Follow the planned track of the active route edition. */
+export interface GuidanceOrder_Track {
+    /**
+     * Rejoin at this waypoint (Waypoint.id, never an index). Absent: the leg the process judges
+     * current, which is how a hand-back from a course or heading order resumes.
+     */
+    resumeFromWaypointId?: string | undefined;
+}
+/** Stop making way and keep station where the order finds her, until told otherwise. */
+export interface GuidanceOrder_Hold {
+}
+export declare const NavigationState: MessageFns<NavigationState>;
+export declare const GuidanceOrder: MessageFns<GuidanceOrder>;
+export declare const GuidanceOrder_Track: MessageFns<GuidanceOrder_Track>;
+export declare const GuidanceOrder_Hold: MessageFns<GuidanceOrder_Hold>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export 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 keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export 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>>]: never;
+};
+export interface MessageFns<T> {
+    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 {};