@rise-maritime/keelson-js 0.5.2 → 0.5.3

package/dist/payloads/Primitives.js

@@ -5,7 +5,7 @@
 //   protoc               v6.30.2
 // source: Primitives.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimestampedQuaternion = exports.TimestampedTimestamp = exports.TimestampedDuration = exports.TimestampedBool = exports.TimestampedString = exports.TimestampedInt64 = exports.TimestampedInt = exports.TimestampedFloat = exports.TimestampedDouble = exports.TimestampedBytes = void 0;
+exports.TimestampedFloatPeriod = exports.TimestampedQuaternion = exports.TimestampedTimestamp = exports.TimestampedDuration = exports.TimestampedBool = exports.TimestampedString = exports.TimestampedInt64 = exports.TimestampedInt = exports.TimestampedFloat = exports.TimestampedDouble = exports.TimestampedBytes = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const Quaternion_1 = require("./foxglove/Quaternion");
@@ -726,6 +726,94 @@ exports.TimestampedQuaternion = {
     },
 };
 typeRegistry_1.messageTypeRegistry.set(exports.TimestampedQuaternion.$type, exports.TimestampedQuaternion);
+function createBaseTimestampedFloatPeriod() {
+    return { $type: "keelson.TimestampedFloatPeriod", timestamp: undefined, value: 0, period: undefined };
+}
+exports.TimestampedFloatPeriod = {
+    $type: "keelson.TimestampedFloatPeriod",
+    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.value !== 0) {
+            writer.uint32(21).float(message.value);
+        }
+        if (message.period !== undefined) {
+            duration_1.Duration.encode(message.period, writer.uint32(26).fork()).join();
+        }
+        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 = createBaseTimestampedFloatPeriod();
+        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 !== 21) {
+                        break;
+                    }
+                    message.value = reader.float();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.period = duration_1.Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.TimestampedFloatPeriod.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            value: isSet(object.value) ? globalThis.Number(object.value) : 0,
+            period: isSet(object.period) ? duration_1.Duration.fromJSON(object.period) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.value !== 0) {
+            obj.value = message.value;
+        }
+        if (message.period !== undefined) {
+            obj.period = duration_1.Duration.toJSON(message.period);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.TimestampedFloatPeriod.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTimestampedFloatPeriod();
+        message.timestamp = object.timestamp ?? undefined;
+        message.value = object.value ?? 0;
+        message.period = (object.period !== undefined && object.period !== null)
+            ? duration_1.Duration.fromPartial(object.period)
+            : undefined;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.TimestampedFloatPeriod.$type, exports.TimestampedFloatPeriod);
 function bytesFromBase64(b64) {
     if (globalThis.Buffer) {
         return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));

package/dist/payloads/ReplayStatus.d.ts

@@ -0,0 +1,76 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * Identifies the replay daemon producing this status. Static across the
+ * daemon's lifetime; populated on every sample so clients can discover and
+ * label replayers via the broadcast alone (no separate RPC needed).
+ */
+export interface DaemonInfo {
+    $type: "keelson.DaemonInfo";
+    /** keelson SDK version, e.g. "0.5.1" */
+    version: string;
+    hostname: string;
+    startedAt: Date | undefined;
+    baseDirectory: string;
+}
+export interface ReplayStatus {
+    $type: "keelson.ReplayStatus";
+    state: ReplayStatus_State;
+    /** Current playhead position in the loaded file. */
+    currentTime: Date | undefined;
+    /** Start and end timestamps of the loaded file. */
+    startTime: Date | undefined;
+    endTime: Date | undefined;
+    /** Playback speed multiplier (1.0 = real time). */
+    playbackSpeed: number;
+    /** Path of the currently loaded MCAP file, or empty if none loaded. */
+    loadedFile: string;
+    /** Number of messages already emitted since the file was loaded. */
+    playedMessageCount: number;
+    /** Total number of messages in the loaded file. */
+    totalMessageCount: number;
+    /** Progress through the file as a percentage in [0.0, 100.0]. */
+    progressPct: number;
+    /** Whether the replayer is configured to loop on end-of-file. */
+    loop: boolean;
+    /** Identification of the daemon producing this sample. See DaemonInfo above. */
+    daemon: DaemonInfo | undefined;
+    /** Progress of an in-flight load_file, 0..100. Zero outside of LOADING. */
+    loadProgressPct: number;
+    /**
+     * Most-recent load_file failure, surfaced through the broadcast because
+     * the RPC reply has already returned OK by the time the worker fails.
+     * Cleared on a successful load. Empty if the most recent load succeeded.
+     */
+    lastLoadError: string;
+}
+export declare enum ReplayStatus_State {
+    STOPPED = 0,
+    PLAYING = 1,
+    PAUSED = 2,
+    LOADING = 3,
+    UNRECOGNIZED = -1
+}
+export declare function replayStatus_StateFromJSON(object: any): ReplayStatus_State;
+export declare function replayStatus_StateToJSON(object: ReplayStatus_State): string;
+export declare const DaemonInfo: MessageFns<DaemonInfo, "keelson.DaemonInfo">;
+export declare const ReplayStatus: MessageFns<ReplayStatus, "keelson.ReplayStatus">;
+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/ReplayStatus.js

@@ -0,0 +1,445 @@
+"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: ReplayStatus.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayStatus = exports.DaemonInfo = exports.replayStatus_StateToJSON = exports.replayStatus_StateFromJSON = exports.ReplayStatus_State = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+var ReplayStatus_State;
+(function (ReplayStatus_State) {
+    ReplayStatus_State[ReplayStatus_State["STOPPED"] = 0] = "STOPPED";
+    ReplayStatus_State[ReplayStatus_State["PLAYING"] = 1] = "PLAYING";
+    ReplayStatus_State[ReplayStatus_State["PAUSED"] = 2] = "PAUSED";
+    ReplayStatus_State[ReplayStatus_State["LOADING"] = 3] = "LOADING";
+    ReplayStatus_State[ReplayStatus_State["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ReplayStatus_State || (exports.ReplayStatus_State = ReplayStatus_State = {}));
+function replayStatus_StateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "STOPPED":
+            return ReplayStatus_State.STOPPED;
+        case 1:
+        case "PLAYING":
+            return ReplayStatus_State.PLAYING;
+        case 2:
+        case "PAUSED":
+            return ReplayStatus_State.PAUSED;
+        case 3:
+        case "LOADING":
+            return ReplayStatus_State.LOADING;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ReplayStatus_State.UNRECOGNIZED;
+    }
+}
+exports.replayStatus_StateFromJSON = replayStatus_StateFromJSON;
+function replayStatus_StateToJSON(object) {
+    switch (object) {
+        case ReplayStatus_State.STOPPED:
+            return "STOPPED";
+        case ReplayStatus_State.PLAYING:
+            return "PLAYING";
+        case ReplayStatus_State.PAUSED:
+            return "PAUSED";
+        case ReplayStatus_State.LOADING:
+            return "LOADING";
+        case ReplayStatus_State.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.replayStatus_StateToJSON = replayStatus_StateToJSON;
+function createBaseDaemonInfo() {
+    return { $type: "keelson.DaemonInfo", version: "", hostname: "", startedAt: undefined, baseDirectory: "" };
+}
+exports.DaemonInfo = {
+    $type: "keelson.DaemonInfo",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.version !== "") {
+            writer.uint32(10).string(message.version);
+        }
+        if (message.hostname !== "") {
+            writer.uint32(18).string(message.hostname);
+        }
+        if (message.startedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.startedAt), writer.uint32(26).fork()).join();
+        }
+        if (message.baseDirectory !== "") {
+            writer.uint32(34).string(message.baseDirectory);
+        }
+        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 = createBaseDaemonInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.hostname = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.startedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.baseDirectory = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.DaemonInfo.$type,
+            version: isSet(object.version) ? globalThis.String(object.version) : "",
+            hostname: isSet(object.hostname) ? globalThis.String(object.hostname) : "",
+            startedAt: isSet(object.startedAt) ? fromJsonTimestamp(object.startedAt) : undefined,
+            baseDirectory: isSet(object.baseDirectory) ? globalThis.String(object.baseDirectory) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        if (message.hostname !== "") {
+            obj.hostname = message.hostname;
+        }
+        if (message.startedAt !== undefined) {
+            obj.startedAt = message.startedAt.toISOString();
+        }
+        if (message.baseDirectory !== "") {
+            obj.baseDirectory = message.baseDirectory;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.DaemonInfo.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDaemonInfo();
+        message.version = object.version ?? "";
+        message.hostname = object.hostname ?? "";
+        message.startedAt = object.startedAt ?? undefined;
+        message.baseDirectory = object.baseDirectory ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.DaemonInfo.$type, exports.DaemonInfo);
+function createBaseReplayStatus() {
+    return {
+        $type: "keelson.ReplayStatus",
+        state: 0,
+        currentTime: undefined,
+        startTime: undefined,
+        endTime: undefined,
+        playbackSpeed: 0,
+        loadedFile: "",
+        playedMessageCount: 0,
+        totalMessageCount: 0,
+        progressPct: 0,
+        loop: false,
+        daemon: undefined,
+        loadProgressPct: 0,
+        lastLoadError: "",
+    };
+}
+exports.ReplayStatus = {
+    $type: "keelson.ReplayStatus",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.state !== 0) {
+            writer.uint32(8).int32(message.state);
+        }
+        if (message.currentTime !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.currentTime), writer.uint32(18).fork()).join();
+        }
+        if (message.startTime !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.startTime), writer.uint32(26).fork()).join();
+        }
+        if (message.endTime !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.endTime), writer.uint32(34).fork()).join();
+        }
+        if (message.playbackSpeed !== 0) {
+            writer.uint32(45).float(message.playbackSpeed);
+        }
+        if (message.loadedFile !== "") {
+            writer.uint32(50).string(message.loadedFile);
+        }
+        if (message.playedMessageCount !== 0) {
+            writer.uint32(56).uint64(message.playedMessageCount);
+        }
+        if (message.totalMessageCount !== 0) {
+            writer.uint32(64).uint64(message.totalMessageCount);
+        }
+        if (message.progressPct !== 0) {
+            writer.uint32(77).float(message.progressPct);
+        }
+        if (message.loop !== false) {
+            writer.uint32(80).bool(message.loop);
+        }
+        if (message.daemon !== undefined) {
+            exports.DaemonInfo.encode(message.daemon, writer.uint32(162).fork()).join();
+        }
+        if (message.loadProgressPct !== 0) {
+            writer.uint32(197).float(message.loadProgressPct);
+        }
+        if (message.lastLoadError !== "") {
+            writer.uint32(202).string(message.lastLoadError);
+        }
+        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 = createBaseReplayStatus();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.state = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.currentTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.startTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.endTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 45) {
+                        break;
+                    }
+                    message.playbackSpeed = reader.float();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.loadedFile = reader.string();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.playedMessageCount = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.totalMessageCount = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 77) {
+                        break;
+                    }
+                    message.progressPct = reader.float();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.loop = reader.bool();
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.daemon = exports.DaemonInfo.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 24: {
+                    if (tag !== 197) {
+                        break;
+                    }
+                    message.loadProgressPct = reader.float();
+                    continue;
+                }
+                case 25: {
+                    if (tag !== 202) {
+                        break;
+                    }
+                    message.lastLoadError = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.ReplayStatus.$type,
+            state: isSet(object.state) ? replayStatus_StateFromJSON(object.state) : 0,
+            currentTime: isSet(object.currentTime) ? fromJsonTimestamp(object.currentTime) : undefined,
+            startTime: isSet(object.startTime) ? fromJsonTimestamp(object.startTime) : undefined,
+            endTime: isSet(object.endTime) ? fromJsonTimestamp(object.endTime) : undefined,
+            playbackSpeed: isSet(object.playbackSpeed) ? globalThis.Number(object.playbackSpeed) : 0,
+            loadedFile: isSet(object.loadedFile) ? globalThis.String(object.loadedFile) : "",
+            playedMessageCount: isSet(object.playedMessageCount) ? globalThis.Number(object.playedMessageCount) : 0,
+            totalMessageCount: isSet(object.totalMessageCount) ? globalThis.Number(object.totalMessageCount) : 0,
+            progressPct: isSet(object.progressPct) ? globalThis.Number(object.progressPct) : 0,
+            loop: isSet(object.loop) ? globalThis.Boolean(object.loop) : false,
+            daemon: isSet(object.daemon) ? exports.DaemonInfo.fromJSON(object.daemon) : undefined,
+            loadProgressPct: isSet(object.loadProgressPct) ? globalThis.Number(object.loadProgressPct) : 0,
+            lastLoadError: isSet(object.lastLoadError) ? globalThis.String(object.lastLoadError) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.state !== 0) {
+            obj.state = replayStatus_StateToJSON(message.state);
+        }
+        if (message.currentTime !== undefined) {
+            obj.currentTime = message.currentTime.toISOString();
+        }
+        if (message.startTime !== undefined) {
+            obj.startTime = message.startTime.toISOString();
+        }
+        if (message.endTime !== undefined) {
+            obj.endTime = message.endTime.toISOString();
+        }
+        if (message.playbackSpeed !== 0) {
+            obj.playbackSpeed = message.playbackSpeed;
+        }
+        if (message.loadedFile !== "") {
+            obj.loadedFile = message.loadedFile;
+        }
+        if (message.playedMessageCount !== 0) {
+            obj.playedMessageCount = Math.round(message.playedMessageCount);
+        }
+        if (message.totalMessageCount !== 0) {
+            obj.totalMessageCount = Math.round(message.totalMessageCount);
+        }
+        if (message.progressPct !== 0) {
+            obj.progressPct = message.progressPct;
+        }
+        if (message.loop !== false) {
+            obj.loop = message.loop;
+        }
+        if (message.daemon !== undefined) {
+            obj.daemon = exports.DaemonInfo.toJSON(message.daemon);
+        }
+        if (message.loadProgressPct !== 0) {
+            obj.loadProgressPct = message.loadProgressPct;
+        }
+        if (message.lastLoadError !== "") {
+            obj.lastLoadError = message.lastLoadError;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ReplayStatus.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseReplayStatus();
+        message.state = object.state ?? 0;
+        message.currentTime = object.currentTime ?? undefined;
+        message.startTime = object.startTime ?? undefined;
+        message.endTime = object.endTime ?? undefined;
+        message.playbackSpeed = object.playbackSpeed ?? 0;
+        message.loadedFile = object.loadedFile ?? "";
+        message.playedMessageCount = object.playedMessageCount ?? 0;
+        message.totalMessageCount = object.totalMessageCount ?? 0;
+        message.progressPct = object.progressPct ?? 0;
+        message.loop = object.loop ?? false;
+        message.daemon = (object.daemon !== undefined && object.daemon !== null)
+            ? exports.DaemonInfo.fromPartial(object.daemon)
+            : undefined;
+        message.loadProgressPct = object.loadProgressPct ?? 0;
+        message.lastLoadError = object.lastLoadError ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.ReplayStatus.$type, exports.ReplayStatus);
+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 longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/payloads/Severity.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export declare enum SeverityLevel {
+    SEVERITY_LEVEL_UNSPECIFIED = 0,
+    INFO = 1,
+    WARNING = 2,
+    CRITICAL = 3,
+    UNRECOGNIZED = -1
+}
+export declare function severityLevelFromJSON(object: any): SeverityLevel;
+export declare function severityLevelToJSON(object: SeverityLevel): string;