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

package/dist/payloads/Mission.d.ts

@@ -0,0 +1,137 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Coordinate } from "./Coordinate";
+import { Empty } from "./google/protobuf/empty";
+/**
+ * One step in a mission. The `step` oneof picks the action; fields
+ * that don't apply to the chosen step are simply absent (no opaque
+ * `param1..4` carrying overloaded meanings).
+ *
+ * Sequence position is the index in Mission.items — there is no
+ * separate `seq` field. Connectors that need wire-level sequence
+ * numbers (e.g. MAVLink MISSION_ITEM_INT) synthesise them from the
+ * list index on upload. A MissionItem published in isolation loses
+ * that context; publishing designs must carry it explicitly (index,
+ * mission id, ...).
+ */
+export interface MissionItem {
+    $type: "keelson.MissionItem";
+    autocontinue: boolean;
+    waypoint?: MissionWaypoint | undefined;
+    loiter?: Loiter | undefined;
+    delay?: Delay | undefined;
+    returnHome?: ReturnHome | undefined;
+    changeSpeed?: ChangeSpeed | undefined;
+    setHome?: SetHome | undefined;
+}
+export interface Mission {
+    $type: "keelson.Mission";
+    items: MissionItem[];
+}
+/**
+ * Drive to a position and (optionally) hold for a fixed duration before
+ * proceeding. `altitude_m` is interpreted per the connector's vehicle
+ * type (surface vessels typically use 0). `acceptance_radius_m = 0`
+ * means "use the autopilot's default".
+ *
+ * Named `MissionWaypoint`, not `Waypoint`: `keelson.Waypoint` is the route
+ * plan artifact in Route.proto — stable id, revision, turn radius,
+ * wheel-over distance, operational context, outgoing leg. The two are not
+ * two spellings of one concept and merging them would produce a union that
+ * serves neither; see protocol-specification.md §6.8. What converges
+ * between them is `Coordinate`, which both now use for position.
+ */
+export interface MissionWaypoint {
+    $type: "keelson.MissionWaypoint";
+    position: Coordinate | undefined;
+    altitudeM: number;
+    acceptanceRadiusM: number;
+    /**
+     * Hold at the waypoint for this many seconds before advancing.
+     * 0 = pass straight through.
+     */
+    holdTimeS: number;
+}
+/** Orbit a position. Termination picks how the loiter ends. */
+export interface Loiter {
+    $type: "keelson.Loiter";
+    position: Coordinate | undefined;
+    altitudeM: number;
+    radiusM: number;
+    /** loiter forever */
+    unlimited?: Empty | undefined;
+    /** loiter for N complete orbits */
+    turns?: number | undefined;
+    /** loiter for this many seconds */
+    durationS?: number | undefined;
+}
+/** Wait in place for a fixed duration before advancing. */
+export interface Delay {
+    $type: "keelson.Delay";
+    durationS: number;
+}
+/** Return to the launch / home position. */
+export interface ReturnHome {
+    $type: "keelson.ReturnHome";
+}
+/** Change the cruise speed used by subsequent waypoints. */
+export interface ChangeSpeed {
+    $type: "keelson.ChangeSpeed";
+    speedMps: number;
+}
+/** Update the vehicle's home position to a specific coordinate. */
+export interface SetHome {
+    $type: "keelson.SetHome";
+    position: Coordinate | undefined;
+    altitudeM: number;
+}
+/**
+ * The mission step the autopilot is currently executing, resolved and
+ * published as state (subject `current_mission_item`). Carries the
+ * context a bare MissionItem lacks: its position in the mission (`seq`,
+ * the index into Mission.items) and the mission length. Published by
+ * connectors that hold the active mission (from upload/download);
+ * state republication, not a derived value — resolving it requires RPC
+ * state no subject carries.
+ */
+export interface CurrentMissionItem {
+    $type: "keelson.CurrentMissionItem";
+    timestamp: Date | undefined;
+    /**
+     * Index of `item` in the active mission (wire seq numbering, matching
+     * upload/download order).
+     */
+    seq: number;
+    /** Number of items in the active mission. */
+    totalItems: number;
+    /** The resolved step at `seq`. */
+    item: MissionItem | undefined;
+}
+export declare const MissionItem: MessageFns<MissionItem, "keelson.MissionItem">;
+export declare const Mission: MessageFns<Mission, "keelson.Mission">;
+export declare const MissionWaypoint: MessageFns<MissionWaypoint, "keelson.MissionWaypoint">;
+export declare const Loiter: MessageFns<Loiter, "keelson.Loiter">;
+export declare const Delay: MessageFns<Delay, "keelson.Delay">;
+export declare const ReturnHome: MessageFns<ReturnHome, "keelson.ReturnHome">;
+export declare const ChangeSpeed: MessageFns<ChangeSpeed, "keelson.ChangeSpeed">;
+export declare const SetHome: MessageFns<SetHome, "keelson.SetHome">;
+export declare const CurrentMissionItem: MessageFns<CurrentMissionItem, "keelson.CurrentMissionItem">;
+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 {};