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

package/dist/index.d.ts

@@ -131,6 +131,43 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly options: {};
         };
     };
+} | {
+    readonly name: "NavigationControl";
+    readonly fullName: "keelson.interfaces.navigation_control.NavigationControl";
+    readonly methods: {
+        readonly load_route: {
+            readonly name: "load_route";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").LoadRouteRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").LoadRouteResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_guidance_order: {
+            readonly name: "set_guidance_order";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetGuidanceOrderRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetGuidanceOrderResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_voyage_status: {
+            readonly name: "set_voyage_status";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetVoyageStatusRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetVoyageStatusResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_navigation_state: {
+            readonly name: "get_navigation_state";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").GetNavigationStateRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationState").MessageFns<import("./interfaces/NavigationState").NavigationState>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
 } | {
     readonly name: "NetworkPingPong";
     readonly fullName: "keelson.interfaces.network_ping_pong.NetworkPingPong";
@@ -156,14 +193,6 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly responseStream: false;
             readonly options: {};
         };
-        readonly describe_file: {
-            readonly name: "describe_file";
-            readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").DescribeFileRequest>;
-            readonly requestStream: false;
-            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").DescribeFileResponse>;
-            readonly responseStream: false;
-            readonly options: {};
-        };
         readonly load_file: {
             readonly name: "load_file";
             readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").LoadFileRequest>;

package/dist/interfaces/NavigationControl.d.ts

@@ -0,0 +1,169 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { GuidanceOrder, NavigationState } from "./NavigationState";
+import { RouteRef } from "./Route";
+import { CommandResult } from "./VehicleCommon";
+import { VoyageStatus } from "./Voyage";
+export declare const protobufPackage = "keelson.interfaces.navigation_control";
+/** Who is calling, and on what authority. Carried by every mutating request. */
+export interface Caller {
+    /**
+     * Identity of the operator and site, or the service, e.g. "ted@ROC-1", "slipway". Recorded in
+     * the responder's decision log, so it should mean something to somebody reading that later.
+     */
+    controllerId: string;
+    /**
+     * The token of the command_authority lease the caller holds. Absent when it holds none, which
+     * is valid only while the responder holds the conn itself (see WHO MAY CALL).
+     */
+    authorityToken?: string | undefined;
+}
+/** Make a route edition the active voyage of this vessel. */
+export interface LoadRouteRequest {
+    /** Client wall-clock at send, for latency logging only. */
+    timestamp: Date | undefined;
+    caller: Caller | undefined;
+    /**
+     * The entity whose route tree holds the edition. RouteRef names no entity, so it always
+     * resolves inside the vessel's own tree; a route drawn for another vessel is copied first.
+     * When it differs from this vessel, the responder reads
+     * `{base}/@v0/{source_entity_id}/pubsub/route/{route_id}/edition/{N}` and republishes it
+     * unchanged under its own vessel, with the same route_id and edition, before activating it.
+     * Editions are immutable, so the copy is the same route, not a new one.
+     */
+    sourceEntityId: string;
+    /**
+     * The edition to sail. Never `latest`: an edition that cannot be resolved is refused, never
+     * silently replaced.
+     */
+    routeRef: RouteRef | undefined;
+    /**
+     * The voyage to activate. Absent: the responder mints one. Present and already a voyage of
+     * this vessel: that voyage is re-pinned to `route_ref` (a reroute).
+     */
+    voyageId?: string | undefined;
+    /** The guidance order to take up once the voyage is active. Absent: TRACK. */
+    initialOrder?: GuidanceOrder | undefined;
+}
+export interface LoadRouteResponse {
+    result: CommandResult;
+    /**
+     * Why not, when result is not ACCEPTED: an unresolvable edition, no conn, another voyage the
+     * responder will not displace. Empty otherwise.
+     */
+    detail: string;
+    /** The voyage now ACTIVE, when result is ACCEPTED. */
+    voyageId?: string | undefined;
+    /** The navigation state the order produced. */
+    state?: NavigationState | undefined;
+}
+/** Change how the vessel is steered while a voyage is active. */
+export interface SetGuidanceOrderRequest {
+    timestamp: Date | undefined;
+    caller: Caller | undefined;
+    order: GuidanceOrder | undefined;
+}
+export interface SetGuidanceOrderResponse {
+    /**
+     * UNSUPPORTED when the responder, or the vehicle behind it, cannot hold the requested frame —
+     * it never substitutes course for heading or the reverse.
+     */
+    result: CommandResult;
+    detail: string;
+    state?: NavigationState | undefined;
+}
+/** Pause, resume, complete or abort the active voyage. */
+export interface SetVoyageStatusRequest {
+    timestamp: Date | undefined;
+    caller: Caller | undefined;
+    voyageId: string;
+    /**
+     * PAUSED, ACTIVE (resume), COMPLETED or ABORTED. PLANNED is refused: a voyage is planned by
+     * publishing it, not by asking the process sailing it.
+     */
+    status: VoyageStatus;
+    /** Why, for the voyage's audit trail. Free text. */
+    reason: string;
+}
+export interface SetVoyageStatusResponse {
+    result: CommandResult;
+    detail: string;
+    state?: NavigationState | undefined;
+}
+export interface GetNavigationStateRequest {
+}
+export declare const Caller: MessageFns<Caller>;
+export declare const LoadRouteRequest: MessageFns<LoadRouteRequest>;
+export declare const LoadRouteResponse: MessageFns<LoadRouteResponse>;
+export declare const SetGuidanceOrderRequest: MessageFns<SetGuidanceOrderRequest>;
+export declare const SetGuidanceOrderResponse: MessageFns<SetGuidanceOrderResponse>;
+export declare const SetVoyageStatusRequest: MessageFns<SetVoyageStatusRequest>;
+export declare const SetVoyageStatusResponse: MessageFns<SetVoyageStatusResponse>;
+export declare const GetNavigationStateRequest: MessageFns<GetNavigationStateRequest>;
+export type NavigationControlDefinition = typeof NavigationControlDefinition;
+export declare const NavigationControlDefinition: {
+    readonly name: "NavigationControl";
+    readonly fullName: "keelson.interfaces.navigation_control.NavigationControl";
+    readonly methods: {
+        /**
+         * Make a route edition this vessel's active voyage, copying it from another vessel's tree when
+         * needed, and take up a guidance order.
+         */
+        readonly load_route: {
+            readonly name: "load_route";
+            readonly requestType: MessageFns<LoadRouteRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<LoadRouteResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Steer by the track, a course, a heading, or hold; optionally with a speed. */
+        readonly set_guidance_order: {
+            readonly name: "set_guidance_order";
+            readonly requestType: MessageFns<SetGuidanceOrderRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<SetGuidanceOrderResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Pause, resume, complete or abort the active voyage. */
+        readonly set_voyage_status: {
+            readonly name: "set_voyage_status";
+            readonly requestType: MessageFns<SetVoyageStatusRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<SetVoyageStatusResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * The current NavigationState — the same payload as the `navigation_state` broadcast, for a
+         * caller that cannot wait for the next one. Needs no authority.
+         */
+        readonly get_navigation_state: {
+            readonly name: "get_navigation_state";
+            readonly requestType: MessageFns<GetNavigationStateRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./NavigationState").MessageFns<NavigationState>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+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 {};