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

package/dist/payloads/ChecklistProcedure.d.ts

@@ -0,0 +1,81 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * The definition of a checklist procedure: its items and their text.
+ *
+ * ChecklistEvent and ChecklistState carry only item *ids* and status, so without this message a
+ * consumer that has not been seeded out of band cannot render a checklist at all — it knows an item
+ * was completed but not what the item said. Published to a key backed by the router's
+ * storage_manager so a joining client can `get` the library rather than being shipped a copy.
+ *
+ * This is the shared definition only. Per-operator state (favourites, last used, local reminders)
+ * stays with the client.
+ */
+export interface ChecklistProcedure {
+    $type: "keelson.ChecklistProcedure";
+    procedureId: string;
+    title: string;
+    description: string;
+    /** Free-form grouping used for filtering, e.g. navigation, handover, emergency, maintenance. */
+    category: string;
+    /**
+     * Version of this definition, e.g. "2.4.1". Advisory: the wire has no upgrade protocol, and a
+     * client applies whatever the storage last held.
+     */
+    version: string;
+    estimatedMinutes: number;
+    items: ChecklistProcedure_Item[];
+    updatedAt: Date | undefined;
+    updatedBy: string;
+}
+export interface ChecklistProcedure_Item {
+    $type: "keelson.ChecklistProcedure.Item";
+    itemId: string;
+    /**
+     * Position in the list as presented, 1-based. Explicit rather than implied by field order so a
+     * renumbering is a visible change to the definition.
+     */
+    number: number;
+    title: string;
+    description: string;
+    /** A procedure is not complete while a required item is outstanding. */
+    isRequired: boolean;
+    /**
+     * The task this item is a sub-task of; empty for a top-level task.
+     *
+     * A parent POINTER rather than a nested `repeated Item children`, deliberately: ChecklistState
+     * and ChecklistEvent both key progress by a flat item_id, and a pointer leaves both untouched.
+     * A consumer that does not understand nesting still renders every task and still records every
+     * completion — it loses the grouping, not the data.
+     *
+     * ONE LEVEL. An item that names a parent must not itself be named as a parent by another item.
+     * Deeper trees are not forbidden by the wire, but no producer should emit them until this
+     * comment says otherwise.
+     *
+     * A parent's own status is DERIVED from its children and is not carried anywhere: a parent has
+     * no ItemState of its own to complete, so the record cannot say a parent is done while one of
+     * its children is outstanding.
+     */
+    parentItemId: string;
+}
+export declare const ChecklistProcedure: MessageFns<ChecklistProcedure, "keelson.ChecklistProcedure">;
+export declare const ChecklistProcedure_Item: MessageFns<ChecklistProcedure_Item, "keelson.ChecklistProcedure.Item">;
+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/ChecklistProcedure.js

@@ -0,0 +1,364 @@
+"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: ChecklistProcedure.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChecklistProcedure_Item = exports.ChecklistProcedure = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+function createBaseChecklistProcedure() {
+    return {
+        $type: "keelson.ChecklistProcedure",
+        procedureId: "",
+        title: "",
+        description: "",
+        category: "",
+        version: "",
+        estimatedMinutes: 0,
+        items: [],
+        updatedAt: undefined,
+        updatedBy: "",
+    };
+}
+exports.ChecklistProcedure = {
+    $type: "keelson.ChecklistProcedure",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.procedureId !== "") {
+            writer.uint32(10).string(message.procedureId);
+        }
+        if (message.title !== "") {
+            writer.uint32(18).string(message.title);
+        }
+        if (message.description !== "") {
+            writer.uint32(26).string(message.description);
+        }
+        if (message.category !== "") {
+            writer.uint32(34).string(message.category);
+        }
+        if (message.version !== "") {
+            writer.uint32(42).string(message.version);
+        }
+        if (message.estimatedMinutes !== 0) {
+            writer.uint32(48).int32(message.estimatedMinutes);
+        }
+        for (const v of message.items) {
+            exports.ChecklistProcedure_Item.encode(v, writer.uint32(58).fork()).join();
+        }
+        if (message.updatedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(66).fork()).join();
+        }
+        if (message.updatedBy !== "") {
+            writer.uint32(74).string(message.updatedBy);
+        }
+        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 = createBaseChecklistProcedure();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.procedureId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.title = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.category = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.estimatedMinutes = reader.int32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.items.push(exports.ChecklistProcedure_Item.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.updatedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.updatedBy = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.ChecklistProcedure.$type,
+            procedureId: isSet(object.procedureId) ? globalThis.String(object.procedureId) : "",
+            title: isSet(object.title) ? globalThis.String(object.title) : "",
+            description: isSet(object.description) ? globalThis.String(object.description) : "",
+            category: isSet(object.category) ? globalThis.String(object.category) : "",
+            version: isSet(object.version) ? globalThis.String(object.version) : "",
+            estimatedMinutes: isSet(object.estimatedMinutes) ? globalThis.Number(object.estimatedMinutes) : 0,
+            items: globalThis.Array.isArray(object?.items)
+                ? object.items.map((e) => exports.ChecklistProcedure_Item.fromJSON(e))
+                : [],
+            updatedAt: isSet(object.updatedAt) ? fromJsonTimestamp(object.updatedAt) : undefined,
+            updatedBy: isSet(object.updatedBy) ? globalThis.String(object.updatedBy) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.procedureId !== "") {
+            obj.procedureId = message.procedureId;
+        }
+        if (message.title !== "") {
+            obj.title = message.title;
+        }
+        if (message.description !== "") {
+            obj.description = message.description;
+        }
+        if (message.category !== "") {
+            obj.category = message.category;
+        }
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        if (message.estimatedMinutes !== 0) {
+            obj.estimatedMinutes = Math.round(message.estimatedMinutes);
+        }
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => exports.ChecklistProcedure_Item.toJSON(e));
+        }
+        if (message.updatedAt !== undefined) {
+            obj.updatedAt = message.updatedAt.toISOString();
+        }
+        if (message.updatedBy !== "") {
+            obj.updatedBy = message.updatedBy;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ChecklistProcedure.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseChecklistProcedure();
+        message.procedureId = object.procedureId ?? "";
+        message.title = object.title ?? "";
+        message.description = object.description ?? "";
+        message.category = object.category ?? "";
+        message.version = object.version ?? "";
+        message.estimatedMinutes = object.estimatedMinutes ?? 0;
+        message.items = object.items?.map((e) => exports.ChecklistProcedure_Item.fromPartial(e)) || [];
+        message.updatedAt = object.updatedAt ?? undefined;
+        message.updatedBy = object.updatedBy ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.ChecklistProcedure.$type, exports.ChecklistProcedure);
+function createBaseChecklistProcedure_Item() {
+    return {
+        $type: "keelson.ChecklistProcedure.Item",
+        itemId: "",
+        number: 0,
+        title: "",
+        description: "",
+        isRequired: false,
+        parentItemId: "",
+    };
+}
+exports.ChecklistProcedure_Item = {
+    $type: "keelson.ChecklistProcedure.Item",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.itemId !== "") {
+            writer.uint32(10).string(message.itemId);
+        }
+        if (message.number !== 0) {
+            writer.uint32(16).int32(message.number);
+        }
+        if (message.title !== "") {
+            writer.uint32(26).string(message.title);
+        }
+        if (message.description !== "") {
+            writer.uint32(34).string(message.description);
+        }
+        if (message.isRequired !== false) {
+            writer.uint32(40).bool(message.isRequired);
+        }
+        if (message.parentItemId !== "") {
+            writer.uint32(50).string(message.parentItemId);
+        }
+        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 = createBaseChecklistProcedure_Item();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.itemId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.number = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.title = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.isRequired = reader.bool();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.parentItemId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.ChecklistProcedure_Item.$type,
+            itemId: isSet(object.itemId) ? globalThis.String(object.itemId) : "",
+            number: isSet(object.number) ? globalThis.Number(object.number) : 0,
+            title: isSet(object.title) ? globalThis.String(object.title) : "",
+            description: isSet(object.description) ? globalThis.String(object.description) : "",
+            isRequired: isSet(object.isRequired) ? globalThis.Boolean(object.isRequired) : false,
+            parentItemId: isSet(object.parentItemId) ? globalThis.String(object.parentItemId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.itemId !== "") {
+            obj.itemId = message.itemId;
+        }
+        if (message.number !== 0) {
+            obj.number = Math.round(message.number);
+        }
+        if (message.title !== "") {
+            obj.title = message.title;
+        }
+        if (message.description !== "") {
+            obj.description = message.description;
+        }
+        if (message.isRequired !== false) {
+            obj.isRequired = message.isRequired;
+        }
+        if (message.parentItemId !== "") {
+            obj.parentItemId = message.parentItemId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ChecklistProcedure_Item.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseChecklistProcedure_Item();
+        message.itemId = object.itemId ?? "";
+        message.number = object.number ?? 0;
+        message.title = object.title ?? "";
+        message.description = object.description ?? "";
+        message.isRequired = object.isRequired ?? false;
+        message.parentItemId = object.parentItemId ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.ChecklistProcedure_Item.$type, exports.ChecklistProcedure_Item);
+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/ChecklistState.d.ts

@@ -0,0 +1,178 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { ChecklistItemEvidence } from "./ChecklistEvidence";
+import { ChecklistProcedure_Item } from "./ChecklistProcedure";
+/**
+ * Snapshot of one RUN of a checklist procedure, used to bootstrap late-joining operators.
+ * Published periodically and on state change for synchronization between ROC sites.
+ *
+ * The unit here is a run, not a procedure. A procedure is a template that may be executed many
+ * times; each execution is a run with its own id, its own progress and its own place in history.
+ * The key's last token is the `run_id`, which is globally unique — so it stays a single token and
+ * the storage's `.../checklist_state/*` expression keeps covering it, and two runs of the same
+ * procedure no longer overwrite each other.
+ */
+export interface ChecklistState {
+    $type: "keelson.ChecklistState";
+    timestamp: Date | undefined;
+    procedureId: string;
+    publishedByOperator: string;
+    publishedByRocSite: string;
+    /**
+     * Number of events this snapshot has incorporated. Used as a version guard: a snapshot
+     * carrying fewer events than a receiver has already applied is stale and must be ignored.
+     *
+     * THE GUARD IS SINGLE-WRITER ONLY. It is a scalar, so it orders two snapshots from the same
+     * publisher and nothing else: two sites that each applied a DIFFERENT twelve events both hold
+     * 12, and each rejects the other as stale rather than merging. A receiver must therefore treat
+     * this as a staleness hint, never as arbitration — the convergence it does not provide comes
+     * from the field-level merge rules in protocol-specification.md §7.2, which hold regardless of
+     * arrival order. See RISE-Maritime/keelson#204 for the key-layout fix that would let this
+     * become load-bearing again by giving every writer a key of its own.
+     */
+    eventCount: number;
+    items: ChecklistState_ItemState[];
+    /** Globally unique, and the last token of this snapshot's key. */
+    runId: string;
+    status: ChecklistState_RunStatus;
+    startedAt: Date | undefined;
+    completedAt: Date | undefined;
+    /**
+     * When a planned run is due. Optional — a run may be queued for this watch with no due time,
+     * which is the common case; only a run with a deadline carries one.
+     */
+    scheduledFor: Date | undefined;
+    /**
+     * The procedure as it was when this run was created. Carried on every snapshot because a
+     * receiver may hold a run whose definition has not arrived off the bus yet, and a run with no
+     * title renders as a bare id in the tab strip and on the board.
+     */
+    procedureTitle: string;
+    procedureVersion: string;
+    /**
+     * The item text this run was actually worked against, written ONLY on the terminal publish.
+     *
+     * Without it a historical run renders against whatever the template says TODAY: edit a
+     * procedure after a run completes and the archive silently shows the new wording beside the old
+     * completion timestamps — a plausible-looking record of something that did not happen. Live
+     * snapshots omit it because the storage keeps only the last value per key, so paying for it on
+     * every tick of an hour-long run buys nothing.
+     *
+     * Once a receiver has seen a snapshot carrying this, it must re-emit it on any subsequent
+     * publish of the same run, or a peer republishing the key strips the archive.
+     */
+    itemsSnapshot: ChecklistProcedure_Item[];
+    /**
+     * Why a run was abandoned, as typed by the operator who stopped it.
+     *
+     * Abandoning is the one checklist act that DEMANDS a reason — completing early deliberately does
+     * not, because closing out early is a legitimate act while stopping without finishing is not
+     * self-explanatory. Without this field that reason lives only in the ChecklistEvent that
+     * announced it, and `checklist_event` has no router storage, so a station bootstrapping from a
+     * snapshot sees RUN_STATUS_ABANDONED with no reason and no way to ever recover one.
+     *
+     * Empty for every non-abandoned run, and empty is also legitimate for an abandoned one published
+     * by a client that did not collect a reason — a consumer must not read "" as "no reason given"
+     * versus "reason lost".
+     */
+    abandonReason: string;
+}
+export declare enum ChecklistState_RunStatus {
+    RUN_STATUS_UNKNOWN = 0,
+    /**
+     * RUN_STATUS_PLANNED - Queued by an operator but not begun. Carries no item progress by definition, which is why
+     * a publisher must not treat "no items" as "nothing to say".
+     */
+    RUN_STATUS_PLANNED = 1,
+    RUN_STATUS_ACTIVE = 2,
+    /** RUN_STATUS_COMPLETED - Terminal. Signed off with every required item done. */
+    RUN_STATUS_COMPLETED = 3,
+    /** RUN_STATUS_ABANDONED - Terminal. Stopped without completing; the reason travels in the ChecklistEvent's `detail`. */
+    RUN_STATUS_ABANDONED = 4,
+    UNRECOGNIZED = -1
+}
+export declare function checklistState_RunStatusFromJSON(object: any): ChecklistState_RunStatus;
+export declare function checklistState_RunStatusToJSON(object: ChecklistState_RunStatus): string;
+export interface ChecklistState_ItemNote {
+    $type: "keelson.ChecklistState.ItemNote";
+    noteId: string;
+    text: string;
+    createdAt: Date | undefined;
+    author: string;
+    authorRocSite: string;
+}
+export interface ChecklistState_ItemState {
+    $type: "keelson.ChecklistState.ItemState";
+    itemId: string;
+    status: ChecklistState_ItemState_ItemStatus;
+    startedAt: Date | undefined;
+    startedBy: string;
+    startedByRocSite: string;
+    completedAt: Date | undefined;
+    completedBy: string;
+    completedByRocSite: string;
+    notes: ChecklistState_ItemNote[];
+    flagged: boolean;
+    flagReason: string;
+    flaggedBy: string;
+    flaggedByRocSite: string;
+    /**
+     * Photos attached to this item — METADATA only; the bytes live on their own keys. See
+     * ChecklistEvidence.proto for why they are not inlined here.
+     *
+     * ADDITIVE, and a receiver must union it by evidence_id rather than replacing. A station that
+     * never saw the attaching event republishes this snapshot with an empty list, and a replacing
+     * merge would erase the evidence everywhere — the same hazard `items_snapshot` carries.
+     */
+    evidence: ChecklistItemEvidence[];
+    /**
+     * When the flag was RAISED — not when this snapshot was published.
+     *
+     * The four fields above say an item is flagged, why, and by whom, but never when. A receiver
+     * bootstrapping from a snapshot therefore cannot date the flag at all, and a history built from
+     * it has to render an undated row beside rows that carry real times. Stamping it from the
+     * snapshot's own timestamp would be worse than leaving it empty: it would assert a time that is
+     * simply wrong, and look authoritative doing it.
+     *
+     * Unset while `flagged` is false, and unset is also what an older publisher sends — so a
+     * consumer must treat absence as "not known", never as "just now".
+     */
+    flaggedAt: Date | undefined;
+}
+/**
+ * The only enum in this family whose zero value is not an UNKNOWN sentinel, and that is
+ * deliberate: an item has no unknown state. It has not been started, which is exactly what
+ * PENDING means, so unset and pending being indistinguishable is the truth rather than an
+ * ambiguity. Adding ITEM_STATUS_UNKNOWN = 0 would renumber every value and silently reinterpret
+ * every recording already on disk, to encode a state that cannot occur.
+ */
+export declare enum ChecklistState_ItemState_ItemStatus {
+    ITEM_STATUS_PENDING = 0,
+    ITEM_STATUS_IN_PROGRESS = 1,
+    ITEM_STATUS_COMPLETED = 2,
+    UNRECOGNIZED = -1
+}
+export declare function checklistState_ItemState_ItemStatusFromJSON(object: any): ChecklistState_ItemState_ItemStatus;
+export declare function checklistState_ItemState_ItemStatusToJSON(object: ChecklistState_ItemState_ItemStatus): string;
+export declare const ChecklistState: MessageFns<ChecklistState, "keelson.ChecklistState">;
+export declare const ChecklistState_ItemNote: MessageFns<ChecklistState_ItemNote, "keelson.ChecklistState.ItemNote">;
+export declare const ChecklistState_ItemState: MessageFns<ChecklistState_ItemState, "keelson.ChecklistState.ItemState">;
+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 {};