@rise-maritime/keelson-js 0.6.0-alpha.255.dev.1 → 0.6.0-alpha.275.dev.2

package/dist/payloads/Encounter.d.ts

@@ -0,0 +1,104 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { ColregSituation, OperationalContext } from "./Route";
+/**
+ * One vessel-to-vessel encounter as own ship's navigation assesses it.
+ *
+ * A record, not a command, and not the advice: what own ship should DO about an encounter is a
+ * NavigationAdvice, which names the encounters it answers. Keeping them apart is what lets an
+ * assessment exist, and be recorded, whether or not anyone acts on it.
+ *
+ * EVERY RECORD IS A FULL RESTATEMENT, for the reason EnvelopeExceedance gives: the store keeps the
+ * last value per key, so a closing record must carry everything the opening one did.
+ */
+export interface Encounter {
+    $type: "keelson.Encounter";
+    timestamp: Date | undefined;
+    /** UUID. Also the trailing key token, stable for the life of the encounter. */
+    encounterId: string;
+    /** Absent when own ship has no voyage; the key then uses "novoyage". */
+    voyageId?: string | undefined;
+    target: Encounter_TargetRef | undefined;
+    targetName: string;
+    /** At this record's timestamp. */
+    rangeM: number;
+    bearingTrueDeg: number;
+    bearingRelativeDeg: number;
+    cpaM?: number | undefined;
+    /** negative: closest approach already past */
+    tcpaS?: number | undefined;
+    /**
+     * Latched when the encounter opened and held until it closes: the rules assign roles once,
+     * and a role that flipped as the geometry evolved would contradict a manoeuvre already begun.
+     * The same ColregSituation a Route leg is annotated with, so a planned leg and a live encounter
+     * compare without mapping. An encounter may also be OVERTAKEN or NONE, which a leg never is.
+     */
+    situation: ColregSituation;
+    ownRole: Encounter_Role;
+    /** Rule references that decided situation and role, e.g. ["15", "16"], ["18(a)(iii)"]. */
+    rules: string[];
+    /** Why, for operators and logs. Consumers MUST NOT parse it. */
+    reasoning: string;
+    risk: Encounter_Risk;
+    peakRisk: Encounter_Risk;
+    openedAt: Date | undefined;
+    /** Absent while open, so an open encounter is distinguishable from one whose close was lost. */
+    closedAt?: Date | undefined;
+    /** The operational context whose thresholds graded the risk. */
+    thresholdContext: OperationalContext;
+}
+/** Own ship's role under the rules, from own ship's side. */
+export declare enum Encounter_Role {
+    ROLE_UNSPECIFIED = 0,
+    /** ROLE_GIVE_WAY - Rules 13, 14, 15, 16, 18: keep out of the way */
+    ROLE_GIVE_WAY = 1,
+    /** ROLE_STAND_ON - Rule 17: keep course and speed */
+    ROLE_STAND_ON = 2,
+    /** ROLE_NONE - Rule 19 (restricted visibility), or no rule applies */
+    ROLE_NONE = 3,
+    UNRECOGNIZED = -1
+}
+export declare function encounter_RoleFromJSON(object: any): Encounter_Role;
+export declare function encounter_RoleToJSON(object: Encounter_Role): string;
+/** UNSPECIFIED is the proto3 default: a producer that never set risk must not read as no risk. */
+export declare enum Encounter_Risk {
+    RISK_UNSPECIFIED = 0,
+    RISK_NONE = 1,
+    RISK_WATCH = 2,
+    RISK_RISK = 3,
+    RISK_DANGER = 4,
+    UNRECOGNIZED = -1
+}
+export declare function encounter_RiskFromJSON(object: any): Encounter_Risk;
+export declare function encounter_RiskToJSON(object: Encounter_Risk): string;
+/** Where the target was heard: the key it was published on, minus the subject. */
+export interface Encounter_TargetRef {
+    $type: "keelson.Encounter.TargetRef";
+    /** e.g. "maritimedb" */
+    entityId: string;
+    /** e.g. "digitraffic" */
+    sourceId: string;
+    /** the @target token, e.g. "mmsi_265000000" */
+    targetId: string;
+}
+export declare const Encounter: MessageFns<Encounter, "keelson.Encounter">;
+export declare const Encounter_TargetRef: MessageFns<Encounter_TargetRef, "keelson.Encounter.TargetRef">;
+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/Encounter.js

@@ -0,0 +1,573 @@
+"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: Encounter.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encounter_TargetRef = exports.Encounter = exports.encounter_RiskToJSON = exports.encounter_RiskFromJSON = exports.Encounter_Risk = exports.encounter_RoleToJSON = exports.encounter_RoleFromJSON = exports.Encounter_Role = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const Route_1 = require("./Route");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+/** Own ship's role under the rules, from own ship's side. */
+var Encounter_Role;
+(function (Encounter_Role) {
+    Encounter_Role[Encounter_Role["ROLE_UNSPECIFIED"] = 0] = "ROLE_UNSPECIFIED";
+    /** ROLE_GIVE_WAY - Rules 13, 14, 15, 16, 18: keep out of the way */
+    Encounter_Role[Encounter_Role["ROLE_GIVE_WAY"] = 1] = "ROLE_GIVE_WAY";
+    /** ROLE_STAND_ON - Rule 17: keep course and speed */
+    Encounter_Role[Encounter_Role["ROLE_STAND_ON"] = 2] = "ROLE_STAND_ON";
+    /** ROLE_NONE - Rule 19 (restricted visibility), or no rule applies */
+    Encounter_Role[Encounter_Role["ROLE_NONE"] = 3] = "ROLE_NONE";
+    Encounter_Role[Encounter_Role["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Encounter_Role || (exports.Encounter_Role = Encounter_Role = {}));
+function encounter_RoleFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "ROLE_UNSPECIFIED":
+            return Encounter_Role.ROLE_UNSPECIFIED;
+        case 1:
+        case "ROLE_GIVE_WAY":
+            return Encounter_Role.ROLE_GIVE_WAY;
+        case 2:
+        case "ROLE_STAND_ON":
+            return Encounter_Role.ROLE_STAND_ON;
+        case 3:
+        case "ROLE_NONE":
+            return Encounter_Role.ROLE_NONE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Encounter_Role.UNRECOGNIZED;
+    }
+}
+exports.encounter_RoleFromJSON = encounter_RoleFromJSON;
+function encounter_RoleToJSON(object) {
+    switch (object) {
+        case Encounter_Role.ROLE_UNSPECIFIED:
+            return "ROLE_UNSPECIFIED";
+        case Encounter_Role.ROLE_GIVE_WAY:
+            return "ROLE_GIVE_WAY";
+        case Encounter_Role.ROLE_STAND_ON:
+            return "ROLE_STAND_ON";
+        case Encounter_Role.ROLE_NONE:
+            return "ROLE_NONE";
+        case Encounter_Role.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.encounter_RoleToJSON = encounter_RoleToJSON;
+/** UNSPECIFIED is the proto3 default: a producer that never set risk must not read as no risk. */
+var Encounter_Risk;
+(function (Encounter_Risk) {
+    Encounter_Risk[Encounter_Risk["RISK_UNSPECIFIED"] = 0] = "RISK_UNSPECIFIED";
+    Encounter_Risk[Encounter_Risk["RISK_NONE"] = 1] = "RISK_NONE";
+    Encounter_Risk[Encounter_Risk["RISK_WATCH"] = 2] = "RISK_WATCH";
+    Encounter_Risk[Encounter_Risk["RISK_RISK"] = 3] = "RISK_RISK";
+    Encounter_Risk[Encounter_Risk["RISK_DANGER"] = 4] = "RISK_DANGER";
+    Encounter_Risk[Encounter_Risk["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Encounter_Risk || (exports.Encounter_Risk = Encounter_Risk = {}));
+function encounter_RiskFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "RISK_UNSPECIFIED":
+            return Encounter_Risk.RISK_UNSPECIFIED;
+        case 1:
+        case "RISK_NONE":
+            return Encounter_Risk.RISK_NONE;
+        case 2:
+        case "RISK_WATCH":
+            return Encounter_Risk.RISK_WATCH;
+        case 3:
+        case "RISK_RISK":
+            return Encounter_Risk.RISK_RISK;
+        case 4:
+        case "RISK_DANGER":
+            return Encounter_Risk.RISK_DANGER;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Encounter_Risk.UNRECOGNIZED;
+    }
+}
+exports.encounter_RiskFromJSON = encounter_RiskFromJSON;
+function encounter_RiskToJSON(object) {
+    switch (object) {
+        case Encounter_Risk.RISK_UNSPECIFIED:
+            return "RISK_UNSPECIFIED";
+        case Encounter_Risk.RISK_NONE:
+            return "RISK_NONE";
+        case Encounter_Risk.RISK_WATCH:
+            return "RISK_WATCH";
+        case Encounter_Risk.RISK_RISK:
+            return "RISK_RISK";
+        case Encounter_Risk.RISK_DANGER:
+            return "RISK_DANGER";
+        case Encounter_Risk.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.encounter_RiskToJSON = encounter_RiskToJSON;
+function createBaseEncounter() {
+    return {
+        $type: "keelson.Encounter",
+        timestamp: undefined,
+        encounterId: "",
+        voyageId: undefined,
+        target: undefined,
+        targetName: "",
+        rangeM: 0,
+        bearingTrueDeg: 0,
+        bearingRelativeDeg: 0,
+        cpaM: undefined,
+        tcpaS: undefined,
+        situation: 0,
+        ownRole: 0,
+        rules: [],
+        reasoning: "",
+        risk: 0,
+        peakRisk: 0,
+        openedAt: undefined,
+        closedAt: undefined,
+        thresholdContext: 0,
+    };
+}
+exports.Encounter = {
+    $type: "keelson.Encounter",
+    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.encounterId !== "") {
+            writer.uint32(18).string(message.encounterId);
+        }
+        if (message.voyageId !== undefined) {
+            writer.uint32(26).string(message.voyageId);
+        }
+        if (message.target !== undefined) {
+            exports.Encounter_TargetRef.encode(message.target, writer.uint32(34).fork()).join();
+        }
+        if (message.targetName !== "") {
+            writer.uint32(42).string(message.targetName);
+        }
+        if (message.rangeM !== 0) {
+            writer.uint32(85).float(message.rangeM);
+        }
+        if (message.bearingTrueDeg !== 0) {
+            writer.uint32(93).float(message.bearingTrueDeg);
+        }
+        if (message.bearingRelativeDeg !== 0) {
+            writer.uint32(101).float(message.bearingRelativeDeg);
+        }
+        if (message.cpaM !== undefined) {
+            writer.uint32(109).float(message.cpaM);
+        }
+        if (message.tcpaS !== undefined) {
+            writer.uint32(117).float(message.tcpaS);
+        }
+        if (message.situation !== 0) {
+            writer.uint32(160).int32(message.situation);
+        }
+        if (message.ownRole !== 0) {
+            writer.uint32(168).int32(message.ownRole);
+        }
+        for (const v of message.rules) {
+            writer.uint32(178).string(v);
+        }
+        if (message.reasoning !== "") {
+            writer.uint32(186).string(message.reasoning);
+        }
+        if (message.risk !== 0) {
+            writer.uint32(240).int32(message.risk);
+        }
+        if (message.peakRisk !== 0) {
+            writer.uint32(248).int32(message.peakRisk);
+        }
+        if (message.openedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.openedAt), writer.uint32(322).fork()).join();
+        }
+        if (message.closedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.closedAt), writer.uint32(330).fork()).join();
+        }
+        if (message.thresholdContext !== 0) {
+            writer.uint32(400).int32(message.thresholdContext);
+        }
+        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 = createBaseEncounter();
+        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 !== 18) {
+                        break;
+                    }
+                    message.encounterId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.voyageId = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.target = exports.Encounter_TargetRef.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.targetName = reader.string();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 85) {
+                        break;
+                    }
+                    message.rangeM = reader.float();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 93) {
+                        break;
+                    }
+                    message.bearingTrueDeg = reader.float();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 101) {
+                        break;
+                    }
+                    message.bearingRelativeDeg = reader.float();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 109) {
+                        break;
+                    }
+                    message.cpaM = reader.float();
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 117) {
+                        break;
+                    }
+                    message.tcpaS = reader.float();
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 160) {
+                        break;
+                    }
+                    message.situation = reader.int32();
+                    continue;
+                }
+                case 21: {
+                    if (tag !== 168) {
+                        break;
+                    }
+                    message.ownRole = reader.int32();
+                    continue;
+                }
+                case 22: {
+                    if (tag !== 178) {
+                        break;
+                    }
+                    message.rules.push(reader.string());
+                    continue;
+                }
+                case 23: {
+                    if (tag !== 186) {
+                        break;
+                    }
+                    message.reasoning = reader.string();
+                    continue;
+                }
+                case 30: {
+                    if (tag !== 240) {
+                        break;
+                    }
+                    message.risk = reader.int32();
+                    continue;
+                }
+                case 31: {
+                    if (tag !== 248) {
+                        break;
+                    }
+                    message.peakRisk = reader.int32();
+                    continue;
+                }
+                case 40: {
+                    if (tag !== 322) {
+                        break;
+                    }
+                    message.openedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 41: {
+                    if (tag !== 330) {
+                        break;
+                    }
+                    message.closedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 50: {
+                    if (tag !== 400) {
+                        break;
+                    }
+                    message.thresholdContext = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.Encounter.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            encounterId: isSet(object.encounterId) ? globalThis.String(object.encounterId) : "",
+            voyageId: isSet(object.voyageId) ? globalThis.String(object.voyageId) : undefined,
+            target: isSet(object.target) ? exports.Encounter_TargetRef.fromJSON(object.target) : undefined,
+            targetName: isSet(object.targetName) ? globalThis.String(object.targetName) : "",
+            rangeM: isSet(object.rangeM) ? globalThis.Number(object.rangeM) : 0,
+            bearingTrueDeg: isSet(object.bearingTrueDeg) ? globalThis.Number(object.bearingTrueDeg) : 0,
+            bearingRelativeDeg: isSet(object.bearingRelativeDeg) ? globalThis.Number(object.bearingRelativeDeg) : 0,
+            cpaM: isSet(object.cpaM) ? globalThis.Number(object.cpaM) : undefined,
+            tcpaS: isSet(object.tcpaS) ? globalThis.Number(object.tcpaS) : undefined,
+            situation: isSet(object.situation) ? (0, Route_1.colregSituationFromJSON)(object.situation) : 0,
+            ownRole: isSet(object.ownRole) ? encounter_RoleFromJSON(object.ownRole) : 0,
+            rules: globalThis.Array.isArray(object?.rules) ? object.rules.map((e) => globalThis.String(e)) : [],
+            reasoning: isSet(object.reasoning) ? globalThis.String(object.reasoning) : "",
+            risk: isSet(object.risk) ? encounter_RiskFromJSON(object.risk) : 0,
+            peakRisk: isSet(object.peakRisk) ? encounter_RiskFromJSON(object.peakRisk) : 0,
+            openedAt: isSet(object.openedAt) ? fromJsonTimestamp(object.openedAt) : undefined,
+            closedAt: isSet(object.closedAt) ? fromJsonTimestamp(object.closedAt) : undefined,
+            thresholdContext: isSet(object.thresholdContext) ? (0, Route_1.operationalContextFromJSON)(object.thresholdContext) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.encounterId !== "") {
+            obj.encounterId = message.encounterId;
+        }
+        if (message.voyageId !== undefined) {
+            obj.voyageId = message.voyageId;
+        }
+        if (message.target !== undefined) {
+            obj.target = exports.Encounter_TargetRef.toJSON(message.target);
+        }
+        if (message.targetName !== "") {
+            obj.targetName = message.targetName;
+        }
+        if (message.rangeM !== 0) {
+            obj.rangeM = message.rangeM;
+        }
+        if (message.bearingTrueDeg !== 0) {
+            obj.bearingTrueDeg = message.bearingTrueDeg;
+        }
+        if (message.bearingRelativeDeg !== 0) {
+            obj.bearingRelativeDeg = message.bearingRelativeDeg;
+        }
+        if (message.cpaM !== undefined) {
+            obj.cpaM = message.cpaM;
+        }
+        if (message.tcpaS !== undefined) {
+            obj.tcpaS = message.tcpaS;
+        }
+        if (message.situation !== 0) {
+            obj.situation = (0, Route_1.colregSituationToJSON)(message.situation);
+        }
+        if (message.ownRole !== 0) {
+            obj.ownRole = encounter_RoleToJSON(message.ownRole);
+        }
+        if (message.rules?.length) {
+            obj.rules = message.rules;
+        }
+        if (message.reasoning !== "") {
+            obj.reasoning = message.reasoning;
+        }
+        if (message.risk !== 0) {
+            obj.risk = encounter_RiskToJSON(message.risk);
+        }
+        if (message.peakRisk !== 0) {
+            obj.peakRisk = encounter_RiskToJSON(message.peakRisk);
+        }
+        if (message.openedAt !== undefined) {
+            obj.openedAt = message.openedAt.toISOString();
+        }
+        if (message.closedAt !== undefined) {
+            obj.closedAt = message.closedAt.toISOString();
+        }
+        if (message.thresholdContext !== 0) {
+            obj.thresholdContext = (0, Route_1.operationalContextToJSON)(message.thresholdContext);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.Encounter.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEncounter();
+        message.timestamp = object.timestamp ?? undefined;
+        message.encounterId = object.encounterId ?? "";
+        message.voyageId = object.voyageId ?? undefined;
+        message.target = (object.target !== undefined && object.target !== null)
+            ? exports.Encounter_TargetRef.fromPartial(object.target)
+            : undefined;
+        message.targetName = object.targetName ?? "";
+        message.rangeM = object.rangeM ?? 0;
+        message.bearingTrueDeg = object.bearingTrueDeg ?? 0;
+        message.bearingRelativeDeg = object.bearingRelativeDeg ?? 0;
+        message.cpaM = object.cpaM ?? undefined;
+        message.tcpaS = object.tcpaS ?? undefined;
+        message.situation = object.situation ?? 0;
+        message.ownRole = object.ownRole ?? 0;
+        message.rules = object.rules?.map((e) => e) || [];
+        message.reasoning = object.reasoning ?? "";
+        message.risk = object.risk ?? 0;
+        message.peakRisk = object.peakRisk ?? 0;
+        message.openedAt = object.openedAt ?? undefined;
+        message.closedAt = object.closedAt ?? undefined;
+        message.thresholdContext = object.thresholdContext ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.Encounter.$type, exports.Encounter);
+function createBaseEncounter_TargetRef() {
+    return { $type: "keelson.Encounter.TargetRef", entityId: "", sourceId: "", targetId: "" };
+}
+exports.Encounter_TargetRef = {
+    $type: "keelson.Encounter.TargetRef",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.entityId !== "") {
+            writer.uint32(10).string(message.entityId);
+        }
+        if (message.sourceId !== "") {
+            writer.uint32(18).string(message.sourceId);
+        }
+        if (message.targetId !== "") {
+            writer.uint32(26).string(message.targetId);
+        }
+        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 = createBaseEncounter_TargetRef();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.entityId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.sourceId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.targetId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.Encounter_TargetRef.$type,
+            entityId: isSet(object.entityId) ? globalThis.String(object.entityId) : "",
+            sourceId: isSet(object.sourceId) ? globalThis.String(object.sourceId) : "",
+            targetId: isSet(object.targetId) ? globalThis.String(object.targetId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.entityId !== "") {
+            obj.entityId = message.entityId;
+        }
+        if (message.sourceId !== "") {
+            obj.sourceId = message.sourceId;
+        }
+        if (message.targetId !== "") {
+            obj.targetId = message.targetId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.Encounter_TargetRef.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEncounter_TargetRef();
+        message.entityId = object.entityId ?? "";
+        message.sourceId = object.sourceId ?? "";
+        message.targetId = object.targetId ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.Encounter_TargetRef.$type, exports.Encounter_TargetRef);
+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;
+}