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

package/dist/payloads/ChecklistEvent.js

@@ -0,0 +1,539 @@
+"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: ChecklistEvent.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChecklistEvent = exports.checklistEvent_TimeFieldToJSON = exports.checklistEvent_TimeFieldFromJSON = exports.ChecklistEvent_TimeField = exports.checklistEvent_EventTypeToJSON = exports.checklistEvent_EventTypeFromJSON = exports.ChecklistEvent_EventType = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const ChecklistEvidence_1 = require("./ChecklistEvidence");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+var ChecklistEvent_EventType;
+(function (ChecklistEvent_EventType) {
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_UNKNOWN"] = 0] = "EVENT_TYPE_UNKNOWN";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_CHECKLIST_OPENED"] = 1] = "EVENT_TYPE_CHECKLIST_OPENED";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_ITEM_STARTED"] = 2] = "EVENT_TYPE_ITEM_STARTED";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_ITEM_COMPLETED"] = 3] = "EVENT_TYPE_ITEM_COMPLETED";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_ITEM_REVERTED"] = 4] = "EVENT_TYPE_ITEM_REVERTED";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_NOTE_ADDED"] = 5] = "EVENT_TYPE_NOTE_ADDED";
+    /**
+     * EVENT_TYPE_ITEM_FLAGGED - An issue raised on an item, and the moment it was cleared.
+     *
+     * Both carry the flag they act on in `reference_id` — the `flag_id`, which is the union key
+     * ChecklistState.ItemState.flags merges on. Without it a receiver folding one of these into
+     * `flags` has nothing to match against and can only append, so resolving a flag would add a
+     * second open one instead of closing the first.
+     *
+     * A publisher of FLAG_RESOLVED must ALSO write the resolution triple on the ItemFlag —
+     * `resolved_at`, `resolved_by`, `resolution` — because that is the half that survives in a
+     * snapshot. The event is the live path; a station bootstrapping later sees only the state.
+     * Those three are absorbing and settled earliest-wins, per protocol-specification.md §7.2: a
+     * peer that never saw the resolution must not reopen it, and two stations genuinely clearing
+     * one flag are decided by the earlier time as a value, never by whose snapshot landed last.
+     */
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_ITEM_FLAGGED"] = 6] = "EVENT_TYPE_ITEM_FLAGGED";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_FLAG_RESOLVED"] = 7] = "EVENT_TYPE_FLAG_RESOLVED";
+    /**
+     * EVENT_TYPE_PROCEDURE_STARTED - The run boundary markers. STARTED moves a run to ACTIVE (from PLANNED, or straight from
+     * creation); COMPLETED is the sign-off once every required item is done.
+     */
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_PROCEDURE_STARTED"] = 8] = "EVENT_TYPE_PROCEDURE_STARTED";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_PROCEDURE_COMPLETED"] = 9] = "EVENT_TYPE_PROCEDURE_COMPLETED";
+    /** EVENT_TYPE_RUN_PLANNED - A run queued for later, with or without a due time. */
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_RUN_PLANNED"] = 10] = "EVENT_TYPE_RUN_PLANNED";
+    /** EVENT_TYPE_RUN_ABANDONED - A run stopped without completing. The reason is required and travels in `detail`. */
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_RUN_ABANDONED"] = 11] = "EVENT_TYPE_RUN_ABANDONED";
+    /**
+     * EVENT_TYPE_EVIDENCE_ATTACHED - A photo attached to an item. The metadata rides in `evidence`; the bytes are published
+     * separately to `checklist_evidence/{evidence_id}`.
+     */
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_EVIDENCE_ATTACHED"] = 12] = "EVENT_TYPE_EVIDENCE_ATTACHED";
+    /**
+     * EVENT_TYPE_TIME_SET - A timestamp corrected after the fact — "I finished at 14:45, I am only ticking it now".
+     *
+     * A dedicated type rather than a backdated ITEM_COMPLETED, because ITEM_COMPLETED resolves
+     * conflicts earliest-wins: a completion moved LATER hits that guard on every station, logs a
+     * "confirmed" row, and changes nothing. The guard is right for genuine concurrent completion
+     * and must not be relaxed for this.
+     *
+     * The corrected instant travels in `corrected_time` and the field it corrects in
+     * `corrected_field`. See those fields for what a receiver does with a publisher that
+     * predates them.
+     *
+     * Applying it patches ONLY that timestamp — status and author are untouched — and it is
+     * recorded as its own kind of entry. In a safety record a corrected time that renders
+     * identically to an original one is a claim nobody can audit.
+     */
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_TIME_SET"] = 13] = "EVENT_TYPE_TIME_SET";
+    /**
+     * EVENT_TYPE_ITEM_REOPENED - An item taken back out of "done", with the reason in `detail`.
+     *
+     * Publishers have been spelling this EVENT_TYPE_ITEM_REVERTED = 4 with the reason in `detail`,
+     * because adding an enum value costs a release cycle. The behaviour and the audit trail were
+     * right; only the name misled — "reverted" reads as undoing a mistake, while reopening is a
+     * deliberate, reasoned act that a supervisor performs on a record that already stands.
+     *
+     * EVENT_TYPE_ITEM_REVERTED stays valid and is deliberately NOT reserved: recordings and
+     * durable snapshots already contain 4, and they must keep decoding. Treat the two as the same
+     * act; prefer this one for anything published from now on.
+     */
+    ChecklistEvent_EventType[ChecklistEvent_EventType["EVENT_TYPE_ITEM_REOPENED"] = 15] = "EVENT_TYPE_ITEM_REOPENED";
+    ChecklistEvent_EventType[ChecklistEvent_EventType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ChecklistEvent_EventType || (exports.ChecklistEvent_EventType = ChecklistEvent_EventType = {}));
+function checklistEvent_EventTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "EVENT_TYPE_UNKNOWN":
+            return ChecklistEvent_EventType.EVENT_TYPE_UNKNOWN;
+        case 1:
+        case "EVENT_TYPE_CHECKLIST_OPENED":
+            return ChecklistEvent_EventType.EVENT_TYPE_CHECKLIST_OPENED;
+        case 2:
+        case "EVENT_TYPE_ITEM_STARTED":
+            return ChecklistEvent_EventType.EVENT_TYPE_ITEM_STARTED;
+        case 3:
+        case "EVENT_TYPE_ITEM_COMPLETED":
+            return ChecklistEvent_EventType.EVENT_TYPE_ITEM_COMPLETED;
+        case 4:
+        case "EVENT_TYPE_ITEM_REVERTED":
+            return ChecklistEvent_EventType.EVENT_TYPE_ITEM_REVERTED;
+        case 5:
+        case "EVENT_TYPE_NOTE_ADDED":
+            return ChecklistEvent_EventType.EVENT_TYPE_NOTE_ADDED;
+        case 6:
+        case "EVENT_TYPE_ITEM_FLAGGED":
+            return ChecklistEvent_EventType.EVENT_TYPE_ITEM_FLAGGED;
+        case 7:
+        case "EVENT_TYPE_FLAG_RESOLVED":
+            return ChecklistEvent_EventType.EVENT_TYPE_FLAG_RESOLVED;
+        case 8:
+        case "EVENT_TYPE_PROCEDURE_STARTED":
+            return ChecklistEvent_EventType.EVENT_TYPE_PROCEDURE_STARTED;
+        case 9:
+        case "EVENT_TYPE_PROCEDURE_COMPLETED":
+            return ChecklistEvent_EventType.EVENT_TYPE_PROCEDURE_COMPLETED;
+        case 10:
+        case "EVENT_TYPE_RUN_PLANNED":
+            return ChecklistEvent_EventType.EVENT_TYPE_RUN_PLANNED;
+        case 11:
+        case "EVENT_TYPE_RUN_ABANDONED":
+            return ChecklistEvent_EventType.EVENT_TYPE_RUN_ABANDONED;
+        case 12:
+        case "EVENT_TYPE_EVIDENCE_ATTACHED":
+            return ChecklistEvent_EventType.EVENT_TYPE_EVIDENCE_ATTACHED;
+        case 13:
+        case "EVENT_TYPE_TIME_SET":
+            return ChecklistEvent_EventType.EVENT_TYPE_TIME_SET;
+        case 15:
+        case "EVENT_TYPE_ITEM_REOPENED":
+            return ChecklistEvent_EventType.EVENT_TYPE_ITEM_REOPENED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ChecklistEvent_EventType.UNRECOGNIZED;
+    }
+}
+exports.checklistEvent_EventTypeFromJSON = checklistEvent_EventTypeFromJSON;
+function checklistEvent_EventTypeToJSON(object) {
+    switch (object) {
+        case ChecklistEvent_EventType.EVENT_TYPE_UNKNOWN:
+            return "EVENT_TYPE_UNKNOWN";
+        case ChecklistEvent_EventType.EVENT_TYPE_CHECKLIST_OPENED:
+            return "EVENT_TYPE_CHECKLIST_OPENED";
+        case ChecklistEvent_EventType.EVENT_TYPE_ITEM_STARTED:
+            return "EVENT_TYPE_ITEM_STARTED";
+        case ChecklistEvent_EventType.EVENT_TYPE_ITEM_COMPLETED:
+            return "EVENT_TYPE_ITEM_COMPLETED";
+        case ChecklistEvent_EventType.EVENT_TYPE_ITEM_REVERTED:
+            return "EVENT_TYPE_ITEM_REVERTED";
+        case ChecklistEvent_EventType.EVENT_TYPE_NOTE_ADDED:
+            return "EVENT_TYPE_NOTE_ADDED";
+        case ChecklistEvent_EventType.EVENT_TYPE_ITEM_FLAGGED:
+            return "EVENT_TYPE_ITEM_FLAGGED";
+        case ChecklistEvent_EventType.EVENT_TYPE_FLAG_RESOLVED:
+            return "EVENT_TYPE_FLAG_RESOLVED";
+        case ChecklistEvent_EventType.EVENT_TYPE_PROCEDURE_STARTED:
+            return "EVENT_TYPE_PROCEDURE_STARTED";
+        case ChecklistEvent_EventType.EVENT_TYPE_PROCEDURE_COMPLETED:
+            return "EVENT_TYPE_PROCEDURE_COMPLETED";
+        case ChecklistEvent_EventType.EVENT_TYPE_RUN_PLANNED:
+            return "EVENT_TYPE_RUN_PLANNED";
+        case ChecklistEvent_EventType.EVENT_TYPE_RUN_ABANDONED:
+            return "EVENT_TYPE_RUN_ABANDONED";
+        case ChecklistEvent_EventType.EVENT_TYPE_EVIDENCE_ATTACHED:
+            return "EVENT_TYPE_EVIDENCE_ATTACHED";
+        case ChecklistEvent_EventType.EVENT_TYPE_TIME_SET:
+            return "EVENT_TYPE_TIME_SET";
+        case ChecklistEvent_EventType.EVENT_TYPE_ITEM_REOPENED:
+            return "EVENT_TYPE_ITEM_REOPENED";
+        case ChecklistEvent_EventType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.checklistEvent_EventTypeToJSON = checklistEvent_EventTypeToJSON;
+/**
+ * Which timestamp an EVENT_TYPE_TIME_SET corrects.
+ *
+ * An enum rather than the field's name as a string, because a string target is matched by
+ * every consumer against its own spelling: a typo is not an error, it is a silent no-op that
+ * logs an audited correction and patches nothing.
+ */
+var ChecklistEvent_TimeField;
+(function (ChecklistEvent_TimeField) {
+    ChecklistEvent_TimeField[ChecklistEvent_TimeField["TIME_FIELD_UNKNOWN"] = 0] = "TIME_FIELD_UNKNOWN";
+    ChecklistEvent_TimeField[ChecklistEvent_TimeField["TIME_FIELD_ITEM_STARTED_AT"] = 1] = "TIME_FIELD_ITEM_STARTED_AT";
+    ChecklistEvent_TimeField[ChecklistEvent_TimeField["TIME_FIELD_ITEM_COMPLETED_AT"] = 2] = "TIME_FIELD_ITEM_COMPLETED_AT";
+    /** TIME_FIELD_RUN_STARTED_AT - The run's own start. Ignores `item_id`. */
+    ChecklistEvent_TimeField[ChecklistEvent_TimeField["TIME_FIELD_RUN_STARTED_AT"] = 3] = "TIME_FIELD_RUN_STARTED_AT";
+    ChecklistEvent_TimeField[ChecklistEvent_TimeField["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ChecklistEvent_TimeField || (exports.ChecklistEvent_TimeField = ChecklistEvent_TimeField = {}));
+function checklistEvent_TimeFieldFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "TIME_FIELD_UNKNOWN":
+            return ChecklistEvent_TimeField.TIME_FIELD_UNKNOWN;
+        case 1:
+        case "TIME_FIELD_ITEM_STARTED_AT":
+            return ChecklistEvent_TimeField.TIME_FIELD_ITEM_STARTED_AT;
+        case 2:
+        case "TIME_FIELD_ITEM_COMPLETED_AT":
+            return ChecklistEvent_TimeField.TIME_FIELD_ITEM_COMPLETED_AT;
+        case 3:
+        case "TIME_FIELD_RUN_STARTED_AT":
+            return ChecklistEvent_TimeField.TIME_FIELD_RUN_STARTED_AT;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ChecklistEvent_TimeField.UNRECOGNIZED;
+    }
+}
+exports.checklistEvent_TimeFieldFromJSON = checklistEvent_TimeFieldFromJSON;
+function checklistEvent_TimeFieldToJSON(object) {
+    switch (object) {
+        case ChecklistEvent_TimeField.TIME_FIELD_UNKNOWN:
+            return "TIME_FIELD_UNKNOWN";
+        case ChecklistEvent_TimeField.TIME_FIELD_ITEM_STARTED_AT:
+            return "TIME_FIELD_ITEM_STARTED_AT";
+        case ChecklistEvent_TimeField.TIME_FIELD_ITEM_COMPLETED_AT:
+            return "TIME_FIELD_ITEM_COMPLETED_AT";
+        case ChecklistEvent_TimeField.TIME_FIELD_RUN_STARTED_AT:
+            return "TIME_FIELD_RUN_STARTED_AT";
+        case ChecklistEvent_TimeField.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.checklistEvent_TimeFieldToJSON = checklistEvent_TimeFieldToJSON;
+function createBaseChecklistEvent() {
+    return {
+        $type: "keelson.ChecklistEvent",
+        timestamp: undefined,
+        eventId: "",
+        eventType: 0,
+        operatorId: "",
+        username: "",
+        role: "",
+        rocSite: "",
+        procedureId: "",
+        itemId: "",
+        detail: "",
+        referenceId: "",
+        runId: "",
+        evidence: undefined,
+        correctedTime: undefined,
+        correctedField: 0,
+    };
+}
+exports.ChecklistEvent = {
+    $type: "keelson.ChecklistEvent",
+    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.eventId !== "") {
+            writer.uint32(18).string(message.eventId);
+        }
+        if (message.eventType !== 0) {
+            writer.uint32(24).int32(message.eventType);
+        }
+        if (message.operatorId !== "") {
+            writer.uint32(34).string(message.operatorId);
+        }
+        if (message.username !== "") {
+            writer.uint32(42).string(message.username);
+        }
+        if (message.role !== "") {
+            writer.uint32(50).string(message.role);
+        }
+        if (message.rocSite !== "") {
+            writer.uint32(58).string(message.rocSite);
+        }
+        if (message.procedureId !== "") {
+            writer.uint32(66).string(message.procedureId);
+        }
+        if (message.itemId !== "") {
+            writer.uint32(74).string(message.itemId);
+        }
+        if (message.detail !== "") {
+            writer.uint32(82).string(message.detail);
+        }
+        if (message.referenceId !== "") {
+            writer.uint32(90).string(message.referenceId);
+        }
+        if (message.runId !== "") {
+            writer.uint32(98).string(message.runId);
+        }
+        if (message.evidence !== undefined) {
+            ChecklistEvidence_1.ChecklistItemEvidence.encode(message.evidence, writer.uint32(106).fork()).join();
+        }
+        if (message.correctedTime !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.correctedTime), writer.uint32(114).fork()).join();
+        }
+        if (message.correctedField !== 0) {
+            writer.uint32(120).int32(message.correctedField);
+        }
+        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 = createBaseChecklistEvent();
+        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.eventId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.eventType = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.operatorId = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.username = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.role = reader.string();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.rocSite = reader.string();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.procedureId = reader.string();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.itemId = reader.string();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.detail = reader.string();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.referenceId = reader.string();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.runId = reader.string();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 106) {
+                        break;
+                    }
+                    message.evidence = ChecklistEvidence_1.ChecklistItemEvidence.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.correctedTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 120) {
+                        break;
+                    }
+                    message.correctedField = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.ChecklistEvent.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            eventId: isSet(object.eventId) ? globalThis.String(object.eventId) : "",
+            eventType: isSet(object.eventType) ? checklistEvent_EventTypeFromJSON(object.eventType) : 0,
+            operatorId: isSet(object.operatorId) ? globalThis.String(object.operatorId) : "",
+            username: isSet(object.username) ? globalThis.String(object.username) : "",
+            role: isSet(object.role) ? globalThis.String(object.role) : "",
+            rocSite: isSet(object.rocSite) ? globalThis.String(object.rocSite) : "",
+            procedureId: isSet(object.procedureId) ? globalThis.String(object.procedureId) : "",
+            itemId: isSet(object.itemId) ? globalThis.String(object.itemId) : "",
+            detail: isSet(object.detail) ? globalThis.String(object.detail) : "",
+            referenceId: isSet(object.referenceId) ? globalThis.String(object.referenceId) : "",
+            runId: isSet(object.runId) ? globalThis.String(object.runId) : "",
+            evidence: isSet(object.evidence) ? ChecklistEvidence_1.ChecklistItemEvidence.fromJSON(object.evidence) : undefined,
+            correctedTime: isSet(object.correctedTime) ? fromJsonTimestamp(object.correctedTime) : undefined,
+            correctedField: isSet(object.correctedField) ? checklistEvent_TimeFieldFromJSON(object.correctedField) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.eventId !== "") {
+            obj.eventId = message.eventId;
+        }
+        if (message.eventType !== 0) {
+            obj.eventType = checklistEvent_EventTypeToJSON(message.eventType);
+        }
+        if (message.operatorId !== "") {
+            obj.operatorId = message.operatorId;
+        }
+        if (message.username !== "") {
+            obj.username = message.username;
+        }
+        if (message.role !== "") {
+            obj.role = message.role;
+        }
+        if (message.rocSite !== "") {
+            obj.rocSite = message.rocSite;
+        }
+        if (message.procedureId !== "") {
+            obj.procedureId = message.procedureId;
+        }
+        if (message.itemId !== "") {
+            obj.itemId = message.itemId;
+        }
+        if (message.detail !== "") {
+            obj.detail = message.detail;
+        }
+        if (message.referenceId !== "") {
+            obj.referenceId = message.referenceId;
+        }
+        if (message.runId !== "") {
+            obj.runId = message.runId;
+        }
+        if (message.evidence !== undefined) {
+            obj.evidence = ChecklistEvidence_1.ChecklistItemEvidence.toJSON(message.evidence);
+        }
+        if (message.correctedTime !== undefined) {
+            obj.correctedTime = message.correctedTime.toISOString();
+        }
+        if (message.correctedField !== 0) {
+            obj.correctedField = checklistEvent_TimeFieldToJSON(message.correctedField);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ChecklistEvent.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseChecklistEvent();
+        message.timestamp = object.timestamp ?? undefined;
+        message.eventId = object.eventId ?? "";
+        message.eventType = object.eventType ?? 0;
+        message.operatorId = object.operatorId ?? "";
+        message.username = object.username ?? "";
+        message.role = object.role ?? "";
+        message.rocSite = object.rocSite ?? "";
+        message.procedureId = object.procedureId ?? "";
+        message.itemId = object.itemId ?? "";
+        message.detail = object.detail ?? "";
+        message.referenceId = object.referenceId ?? "";
+        message.runId = object.runId ?? "";
+        message.evidence = (object.evidence !== undefined && object.evidence !== null)
+            ? ChecklistEvidence_1.ChecklistItemEvidence.fromPartial(object.evidence)
+            : undefined;
+        message.correctedTime = object.correctedTime ?? undefined;
+        message.correctedField = object.correctedField ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.ChecklistEvent.$type, exports.ChecklistEvent);
+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/ChecklistEvidence.d.ts

@@ -0,0 +1,79 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * A photo attached to a checklist item as evidence that a check was actually performed.
+ *
+ * METADATA ONLY. The image bytes live on their own key — `checklist_evidence/{evidence_id}`,
+ * carrying a `foxglove.CompressedImage` — and this travels inside `ChecklistState.ItemState` and
+ * `ChecklistEvent`. The split is not tidiness: a ChecklistState snapshot is republished every 30
+ * seconds by every station holding an active run, so bytes here would put megabytes on the wire
+ * twice a minute, forever, into a durable store. `ChecklistState.items_snapshot` carries the same
+ * warning for the same reason.
+ *
+ * A receiver renders a tile from this alone. Fetching the bytes is a separate, lazy, one-shot read
+ * — which is why `byte_size` and the dimensions are here: a station on a poor link decides whether
+ * to fetch, and the grid does not reflow as images land.
+ */
+export interface ChecklistItemEvidence {
+    $type: "keelson.ChecklistItemEvidence";
+    /**
+     * Globally unique, and the last token of the key the bytes live on. Single token by
+     * construction, so the router's `.../checklist_evidence/*` storage covers it.
+     */
+    evidenceId: string;
+    /**
+     * What the operator says this shows. Optional but strongly encouraged: a photo with no caption
+     * is evidence of something nobody can name later.
+     */
+    caption: string;
+    /** When the image was TAKEN, which is not necessarily when it was attached. */
+    capturedAt: Date | undefined;
+    author: string;
+    authorSite: string;
+    /**
+     * Full media type, e.g. "image/jpeg". Drives the Blob the receiver builds, and is echoed into
+     * the CompressedImage's own `format` so a recovered blob is self-describing.
+     */
+    mediaType: string;
+    byteSize: number;
+    /** So a thumbnail can reserve its space before the bytes arrive. */
+    width: number;
+    height: number;
+    /**
+     * "Operator uploaded a photo" and "live camera still at 14:32" are different evidentiary
+     * claims, and a safety record should not flatten them into one.
+     */
+    source: ChecklistItemEvidence_Source;
+}
+export declare enum ChecklistItemEvidence_Source {
+    SOURCE_UNKNOWN = 0,
+    /** SOURCE_FILE - Chosen from the operator's device — on a phone or tablet this is the camera. */
+    SOURCE_FILE = 1,
+    /** SOURCE_CAMERA - A still grabbed from a live vessel camera feed at the moment of capture. */
+    SOURCE_CAMERA = 2,
+    /** SOURCE_CHART - The chart as it stood when the check was made. */
+    SOURCE_CHART = 3,
+    UNRECOGNIZED = -1
+}
+export declare function checklistItemEvidence_SourceFromJSON(object: any): ChecklistItemEvidence_Source;
+export declare function checklistItemEvidence_SourceToJSON(object: ChecklistItemEvidence_Source): string;
+export declare const ChecklistItemEvidence: MessageFns<ChecklistItemEvidence, "keelson.ChecklistItemEvidence">;
+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 {};