@rise-maritime/keelson-js 0.5.2 → 0.5.3

package/dist/payloads/Severity.js

@@ -0,0 +1,59 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               v6.30.2
+// source: Severity.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.severityLevelToJSON = exports.severityLevelFromJSON = exports.SeverityLevel = void 0;
+/* eslint-disable */
+/**
+ * Shared severity vocabulary for alerts and events across payloads
+ * (weather, route, ...). Keep this the single source of truth so the bus
+ * does not accumulate per-domain severity scales.
+ */
+var SeverityLevel;
+(function (SeverityLevel) {
+    SeverityLevel[SeverityLevel["SEVERITY_LEVEL_UNSPECIFIED"] = 0] = "SEVERITY_LEVEL_UNSPECIFIED";
+    SeverityLevel[SeverityLevel["INFO"] = 1] = "INFO";
+    SeverityLevel[SeverityLevel["WARNING"] = 2] = "WARNING";
+    SeverityLevel[SeverityLevel["CRITICAL"] = 3] = "CRITICAL";
+    SeverityLevel[SeverityLevel["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(SeverityLevel || (exports.SeverityLevel = SeverityLevel = {}));
+function severityLevelFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SEVERITY_LEVEL_UNSPECIFIED":
+            return SeverityLevel.SEVERITY_LEVEL_UNSPECIFIED;
+        case 1:
+        case "INFO":
+            return SeverityLevel.INFO;
+        case 2:
+        case "WARNING":
+            return SeverityLevel.WARNING;
+        case 3:
+        case "CRITICAL":
+            return SeverityLevel.CRITICAL;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return SeverityLevel.UNRECOGNIZED;
+    }
+}
+exports.severityLevelFromJSON = severityLevelFromJSON;
+function severityLevelToJSON(object) {
+    switch (object) {
+        case SeverityLevel.SEVERITY_LEVEL_UNSPECIFIED:
+            return "SEVERITY_LEVEL_UNSPECIFIED";
+        case SeverityLevel.INFO:
+            return "INFO";
+        case SeverityLevel.WARNING:
+            return "WARNING";
+        case SeverityLevel.CRITICAL:
+            return "CRITICAL";
+        case SeverityLevel.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.severityLevelToJSON = severityLevelToJSON;

package/dist/payloads/VehicleState.d.ts

@@ -0,0 +1,56 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export interface VehicleState {
+    $type: "keelson.VehicleState";
+    /** The source timestamp of the state report */
+    timestamp: Date | undefined;
+    state: VehicleState_State;
+}
+/**
+ * Vehicle-agnostic operational lifecycle / severity state. Maps 1:1 from
+ * MAVLink HEARTBEAT MAV_STATE, but the values are universal operational
+ * concepts (not a MAVLink-specific shape): any vehicle connector can
+ * publish this. The severity tail (CRITICAL / EMERGENCY / TERMINATED) is
+ * the failsafe axis that per-sensor health (sensor_status) cannot express.
+ */
+export declare enum VehicleState_State {
+    /** STATE_UNKNOWN - boot/uninitialised or indeterminate */
+    STATE_UNKNOWN = 0,
+    STATE_BOOTING = 1,
+    STATE_CALIBRATING = 2,
+    /** STATE_STANDBY - ready, not active */
+    STATE_STANDBY = 3,
+    /** STATE_ACTIVE - armed / operating normally */
+    STATE_ACTIVE = 4,
+    /** STATE_CRITICAL - non-normal but still controllable */
+    STATE_CRITICAL = 5,
+    /** STATE_EMERGENCY - mayday */
+    STATE_EMERGENCY = 6,
+    /** STATE_SHUTDOWN - powering off */
+    STATE_SHUTDOWN = 7,
+    /** STATE_TERMINATED - flight/operation terminated */
+    STATE_TERMINATED = 8,
+    UNRECOGNIZED = -1
+}
+export declare function vehicleState_StateFromJSON(object: any): VehicleState_State;
+export declare function vehicleState_StateToJSON(object: VehicleState_State): string;
+export declare const VehicleState: MessageFns<VehicleState, "keelson.VehicleState">;
+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 {};

package/dist/payloads/VehicleState.js

@@ -0,0 +1,196 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               v6.30.2
+// source: VehicleState.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VehicleState = exports.vehicleState_StateToJSON = exports.vehicleState_StateFromJSON = exports.VehicleState_State = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+/**
+ * Vehicle-agnostic operational lifecycle / severity state. Maps 1:1 from
+ * MAVLink HEARTBEAT MAV_STATE, but the values are universal operational
+ * concepts (not a MAVLink-specific shape): any vehicle connector can
+ * publish this. The severity tail (CRITICAL / EMERGENCY / TERMINATED) is
+ * the failsafe axis that per-sensor health (sensor_status) cannot express.
+ */
+var VehicleState_State;
+(function (VehicleState_State) {
+    /** STATE_UNKNOWN - boot/uninitialised or indeterminate */
+    VehicleState_State[VehicleState_State["STATE_UNKNOWN"] = 0] = "STATE_UNKNOWN";
+    VehicleState_State[VehicleState_State["STATE_BOOTING"] = 1] = "STATE_BOOTING";
+    VehicleState_State[VehicleState_State["STATE_CALIBRATING"] = 2] = "STATE_CALIBRATING";
+    /** STATE_STANDBY - ready, not active */
+    VehicleState_State[VehicleState_State["STATE_STANDBY"] = 3] = "STATE_STANDBY";
+    /** STATE_ACTIVE - armed / operating normally */
+    VehicleState_State[VehicleState_State["STATE_ACTIVE"] = 4] = "STATE_ACTIVE";
+    /** STATE_CRITICAL - non-normal but still controllable */
+    VehicleState_State[VehicleState_State["STATE_CRITICAL"] = 5] = "STATE_CRITICAL";
+    /** STATE_EMERGENCY - mayday */
+    VehicleState_State[VehicleState_State["STATE_EMERGENCY"] = 6] = "STATE_EMERGENCY";
+    /** STATE_SHUTDOWN - powering off */
+    VehicleState_State[VehicleState_State["STATE_SHUTDOWN"] = 7] = "STATE_SHUTDOWN";
+    /** STATE_TERMINATED - flight/operation terminated */
+    VehicleState_State[VehicleState_State["STATE_TERMINATED"] = 8] = "STATE_TERMINATED";
+    VehicleState_State[VehicleState_State["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(VehicleState_State || (exports.VehicleState_State = VehicleState_State = {}));
+function vehicleState_StateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "STATE_UNKNOWN":
+            return VehicleState_State.STATE_UNKNOWN;
+        case 1:
+        case "STATE_BOOTING":
+            return VehicleState_State.STATE_BOOTING;
+        case 2:
+        case "STATE_CALIBRATING":
+            return VehicleState_State.STATE_CALIBRATING;
+        case 3:
+        case "STATE_STANDBY":
+            return VehicleState_State.STATE_STANDBY;
+        case 4:
+        case "STATE_ACTIVE":
+            return VehicleState_State.STATE_ACTIVE;
+        case 5:
+        case "STATE_CRITICAL":
+            return VehicleState_State.STATE_CRITICAL;
+        case 6:
+        case "STATE_EMERGENCY":
+            return VehicleState_State.STATE_EMERGENCY;
+        case 7:
+        case "STATE_SHUTDOWN":
+            return VehicleState_State.STATE_SHUTDOWN;
+        case 8:
+        case "STATE_TERMINATED":
+            return VehicleState_State.STATE_TERMINATED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return VehicleState_State.UNRECOGNIZED;
+    }
+}
+exports.vehicleState_StateFromJSON = vehicleState_StateFromJSON;
+function vehicleState_StateToJSON(object) {
+    switch (object) {
+        case VehicleState_State.STATE_UNKNOWN:
+            return "STATE_UNKNOWN";
+        case VehicleState_State.STATE_BOOTING:
+            return "STATE_BOOTING";
+        case VehicleState_State.STATE_CALIBRATING:
+            return "STATE_CALIBRATING";
+        case VehicleState_State.STATE_STANDBY:
+            return "STATE_STANDBY";
+        case VehicleState_State.STATE_ACTIVE:
+            return "STATE_ACTIVE";
+        case VehicleState_State.STATE_CRITICAL:
+            return "STATE_CRITICAL";
+        case VehicleState_State.STATE_EMERGENCY:
+            return "STATE_EMERGENCY";
+        case VehicleState_State.STATE_SHUTDOWN:
+            return "STATE_SHUTDOWN";
+        case VehicleState_State.STATE_TERMINATED:
+            return "STATE_TERMINATED";
+        case VehicleState_State.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.vehicleState_StateToJSON = vehicleState_StateToJSON;
+function createBaseVehicleState() {
+    return { $type: "keelson.VehicleState", timestamp: undefined, state: 0 };
+}
+exports.VehicleState = {
+    $type: "keelson.VehicleState",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.timestamp !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).join();
+        }
+        if (message.state !== 0) {
+            writer.uint32(16).int32(message.state);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseVehicleState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.state = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.VehicleState.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            state: isSet(object.state) ? vehicleState_StateFromJSON(object.state) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.state !== 0) {
+            obj.state = vehicleState_StateToJSON(message.state);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.VehicleState.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseVehicleState();
+        message.timestamp = object.timestamp ?? undefined;
+        message.state = object.state ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.VehicleState.$type, exports.VehicleState);
+function toTimestamp(date) {
+    const seconds = Math.trunc(date.getTime() / 1000);
+    const nanos = (date.getTime() % 1000) * 1000000;
+    return { $type: "google.protobuf.Timestamp", seconds, nanos };
+}
+function fromTimestamp(t) {
+    let millis = (t.seconds || 0) * 1000;
+    millis += (t.nanos || 0) / 1000000;
+    return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+    if (o instanceof globalThis.Date) {
+        return o;
+    }
+    else if (typeof o === "string") {
+        return new globalThis.Date(o);
+    }
+    else {
+        return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/payloads/Weather.d.ts

@@ -0,0 +1,148 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { SeverityLevel } from "./Severity";
+import { LocationFix } from "./foxglove/LocationFix";
+/**
+ * Observed precipitation type. Published on the precipitation_type subject.
+ * Intensity is intentionally not modelled here: it is derivable from
+ * precipitation_rate_mmph and is therefore a consumer-side mapping.
+ */
+export interface PrecipitationType {
+    $type: "keelson.PrecipitationType";
+    timestamp: Date | undefined;
+    type: PrecipitationType_Type;
+}
+export declare enum PrecipitationType_Type {
+    TYPE_UNSPECIFIED = 0,
+    /** NONE - observed dry */
+    NONE = 1,
+    RAIN = 2,
+    DRIZZLE = 3,
+    SNOW = 4,
+    SLEET = 5,
+    HAIL = 6,
+    FREEZING_RAIN = 7,
+    MIXED = 8,
+    UNRECOGNIZED = -1
+}
+export declare function precipitationType_TypeFromJSON(object: any): PrecipitationType_Type;
+export declare function precipitationType_TypeToJSON(object: PrecipitationType_Type): string;
+/** Observed ice type (WMO sea-ice nomenclature). Published on the ice_type subject. */
+export interface IceType {
+    $type: "keelson.IceType";
+    timestamp: Date | undefined;
+    type: IceType_Type;
+}
+export declare enum IceType_Type {
+    TYPE_UNSPECIFIED = 0,
+    FRAZIL = 1,
+    GREASE = 2,
+    SLUSH = 3,
+    SHUGA = 4,
+    NILAS = 5,
+    PANCAKE = 6,
+    FIRST_YEAR = 7,
+    MULTI_YEAR = 8,
+    GLACIER = 9,
+    ICEBERG = 10,
+    UNRECOGNIZED = -1
+}
+export declare function iceType_TypeFromJSON(object: any): IceType_Type;
+export declare function iceType_TypeToJSON(object: IceType_Type): string;
+/**
+ * A weather warning issued by an external authority (SMHI, NOAA, ...).
+ * Quarantined external product: free-form pass-through fields, provenance, and
+ * a validity window. Not assembled from live measurement subjects.
+ */
+export interface WeatherAlert {
+    $type: "keelson.WeatherAlert";
+    /** Stable, issuer-scoped identifier. */
+    id: string;
+    /** Shared severity vocabulary (Severity.proto) -- no per-domain scale. */
+    severity: SeverityLevel;
+    /**
+     * Free-form category as issued, e.g. "gale", "tropical-cyclone", "ice".
+     * A pass-through label, intentionally not an enum keelson maintains.
+     */
+    category: string;
+    headline: string;
+    description: string;
+    /** Validity window. */
+    effectiveAt: Date | undefined;
+    expiresAt: Date | undefined;
+    /** Provenance. */
+    issuer: string;
+    affectedAreas: string[];
+}
+/**
+ * A weather forecast for a location, as issued by an external model / source.
+ * Quarantined external product with confined scope: it enumerates exactly the
+ * quantities the contract predicts and does NOT embed live measurement types.
+ */
+export interface WeatherForecast {
+    $type: "keelson.WeatherForecast";
+    /** Location the forecast applies to. */
+    location: LocationFix | undefined;
+    /** Provenance. */
+    issuedAt: Date | undefined;
+    /** e.g. "ECMWF", "GFS", model-run name */
+    source: string;
+    /** Ordered series of predicted valid-times. */
+    steps: WeatherForecast_Step[];
+    /** Alerts attached to this forecast. */
+    alerts: WeatherAlert[];
+}
+/**
+ * One predicted valid-time. Nested on purpose: this type is confined to the
+ * forecast contract -- it cannot acquire its own subject and cannot be reused
+ * by live-domain code. Field NAMES mirror the live atomic subjects so a
+ * consumer reads them without translation, but the TYPES are local floats:
+ * the external contract stays self-contained and drags no live enums across.
+ *
+ * `optional` gives explicit presence -- a model that does not predict a field
+ * omits it, which is distinct from a real 0.0.
+ */
+export interface WeatherForecast_Step {
+    $type: "keelson.WeatherForecast.Step";
+    validAt: Date | undefined;
+    trueWindSpeedMps?: number | undefined;
+    trueWindDirectionDeg?: number | undefined;
+    trueWindGustMps?: number | undefined;
+    waveHeightSignificantM?: number | undefined;
+    wavePeriodS?: number | undefined;
+    waveTrueDirectionDeg?: number | undefined;
+    precipitationRateMmph?: number | undefined;
+    /** PoP -- a forecast concept, [0, 100] */
+    precipitationProbabilityPct?: number | undefined;
+    visibilityRangeM?: number | undefined;
+    airTemperatureCelsius?: number | undefined;
+    /**
+     * Deliberately limited to the marine-relevant core. Extend when a real
+     * producer needs more -- provisional until then.
+     */
+    airPressurePa?: number | undefined;
+}
+export declare const PrecipitationType: MessageFns<PrecipitationType, "keelson.PrecipitationType">;
+export declare const IceType: MessageFns<IceType, "keelson.IceType">;
+export declare const WeatherAlert: MessageFns<WeatherAlert, "keelson.WeatherAlert">;
+export declare const WeatherForecast: MessageFns<WeatherForecast, "keelson.WeatherForecast">;
+export declare const WeatherForecast_Step: MessageFns<WeatherForecast_Step, "keelson.WeatherForecast.Step">;
+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 {};