@fivenet-app/gen 2025.5.2 → 2025.9.1

package/resources/collab/collab.ts

@@ -0,0 +1,817 @@
+// @generated by protobuf-ts 2.11.1 with parameter force_server_none,long_type_number,optimize_speed,ts_nocheck
+// @generated from protobuf file "resources/collab/collab.proto" (package "resources.collab", syntax proto3)
+// tslint:disable
+// @ts-nocheck
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * @generated from protobuf message resources.collab.ClientPacket
+ */
+export interface ClientPacket {
+    /**
+     * @generated from protobuf oneof: msg
+     */
+    msg: {
+        oneofKind: "hello";
+        /**
+         * Must be the first message
+         *
+         * @generated from protobuf field: resources.collab.CollabInit hello = 1
+         */
+        hello: CollabInit;
+    } | {
+        oneofKind: "syncStep";
+        /**
+         * @generated from protobuf field: resources.collab.SyncStep sync_step = 2
+         */
+        syncStep: SyncStep;
+    } | {
+        oneofKind: "yjsUpdate";
+        /**
+         * @generated from protobuf field: resources.collab.YjsUpdate yjs_update = 3
+         */
+        yjsUpdate: YjsUpdate;
+    } | {
+        oneofKind: "awareness";
+        /**
+         * @generated from protobuf field: resources.collab.AwarenessPing awareness = 4
+         */
+        awareness: AwarenessPing;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message resources.collab.CollabInit
+ */
+export interface CollabInit {
+    /**
+     * @generated from protobuf field: int64 target_id = 1
+     */
+    targetId: number;
+}
+/**
+ * @generated from protobuf message resources.collab.SyncStep
+ */
+export interface SyncStep {
+    /**
+     * @generated from protobuf field: int32 step = 1
+     */
+    step: number;
+    /**
+     * @generated from protobuf field: bytes data = 2
+     */
+    data: Uint8Array;
+    /**
+     * @generated from protobuf field: optional uint64 receiver_id = 3
+     */
+    receiverId?: number;
+}
+/**
+ * @generated from protobuf message resources.collab.YjsUpdate
+ */
+export interface YjsUpdate {
+    /**
+     * @generated from protobuf field: bytes data = 1
+     */
+    data: Uint8Array;
+}
+/**
+ * @generated from protobuf message resources.collab.AwarenessPing
+ */
+export interface AwarenessPing {
+    /**
+     * @generated from protobuf field: bytes data = 1
+     */
+    data: Uint8Array;
+}
+/**
+ * @generated from protobuf message resources.collab.ServerPacket
+ */
+export interface ServerPacket {
+    /**
+     * Who generated this packet (same ID used in awareness)
+     *
+     * @generated from protobuf field: uint64 sender_id = 1
+     */
+    senderId: number;
+    /**
+     * @generated from protobuf oneof: msg
+     */
+    msg: {
+        oneofKind: "handshake";
+        /**
+         * @generated from protobuf field: resources.collab.CollabHandshake handshake = 2
+         */
+        handshake: CollabHandshake;
+    } | {
+        oneofKind: "syncStep";
+        /**
+         * @generated from protobuf field: resources.collab.SyncStep sync_step = 3
+         */
+        syncStep: SyncStep;
+    } | {
+        oneofKind: "yjsUpdate";
+        /**
+         * @generated from protobuf field: resources.collab.YjsUpdate yjs_update = 4
+         */
+        yjsUpdate: YjsUpdate;
+    } | {
+        oneofKind: "awareness";
+        /**
+         * @generated from protobuf field: resources.collab.AwarenessPing awareness = 5
+         */
+        awareness: AwarenessPing;
+    } | {
+        oneofKind: "targetSaved";
+        /**
+         * @generated from protobuf field: resources.collab.TargetSaved target_saved = 6
+         */
+        targetSaved: TargetSaved;
+    } | {
+        oneofKind: "promote";
+        /**
+         * @generated from protobuf field: resources.collab.FirstPromote promote = 7
+         */
+        promote: FirstPromote;
+    } | {
+        oneofKind: "clientUpdate";
+        /**
+         * @generated from protobuf field: resources.collab.ClientUpdate client_update = 8
+         */
+        clientUpdate: ClientUpdate;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message resources.collab.CollabHandshake
+ */
+export interface CollabHandshake {
+    /**
+     * @generated from protobuf field: uint64 client_id = 1
+     */
+    clientId: number;
+    /**
+     * @generated from protobuf field: bool first = 2
+     */
+    first: boolean;
+}
+/**
+ * @generated from protobuf message resources.collab.TargetSaved
+ */
+export interface TargetSaved {
+    /**
+     * @generated from protobuf field: int64 target_id = 1
+     */
+    targetId: number;
+}
+/**
+ * @generated from protobuf message resources.collab.FirstPromote
+ */
+export interface FirstPromote {
+}
+/**
+ * @generated from protobuf message resources.collab.ClientUpdate
+ */
+export interface ClientUpdate {
+    /**
+     * @generated from protobuf field: bool joined = 1
+     */
+    joined: boolean;
+    /**
+     * @generated from protobuf field: uint64 client_id = 2
+     */
+    clientId: number;
+    /**
+     * @generated from protobuf field: optional string label = 3
+     */
+    label?: string;
+}
+/**
+ * @generated from protobuf enum resources.collab.ClientRole
+ */
+export enum ClientRole {
+    /**
+     * @generated from protobuf enum value: CLIENT_ROLE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from protobuf enum value: CLIENT_ROLE_READER = 1;
+     */
+    READER = 1,
+    /**
+     * @generated from protobuf enum value: CLIENT_ROLE_WRITER = 2;
+     */
+    WRITER = 2
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class ClientPacket$Type extends MessageType<ClientPacket> {
+    constructor() {
+        super("resources.collab.ClientPacket", [
+            { no: 1, name: "hello", kind: "message", oneof: "msg", T: () => CollabInit },
+            { no: 2, name: "sync_step", kind: "message", oneof: "msg", T: () => SyncStep },
+            { no: 3, name: "yjs_update", kind: "message", oneof: "msg", T: () => YjsUpdate },
+            { no: 4, name: "awareness", kind: "message", oneof: "msg", T: () => AwarenessPing }
+        ]);
+    }
+    create(value?: PartialMessage<ClientPacket>): ClientPacket {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.msg = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<ClientPacket>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClientPacket): ClientPacket {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.collab.CollabInit hello */ 1:
+                    message.msg = {
+                        oneofKind: "hello",
+                        hello: CollabInit.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).hello)
+                    };
+                    break;
+                case /* resources.collab.SyncStep sync_step */ 2:
+                    message.msg = {
+                        oneofKind: "syncStep",
+                        syncStep: SyncStep.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).syncStep)
+                    };
+                    break;
+                case /* resources.collab.YjsUpdate yjs_update */ 3:
+                    message.msg = {
+                        oneofKind: "yjsUpdate",
+                        yjsUpdate: YjsUpdate.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).yjsUpdate)
+                    };
+                    break;
+                case /* resources.collab.AwarenessPing awareness */ 4:
+                    message.msg = {
+                        oneofKind: "awareness",
+                        awareness: AwarenessPing.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).awareness)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ClientPacket, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.collab.CollabInit hello = 1; */
+        if (message.msg.oneofKind === "hello")
+            CollabInit.internalBinaryWrite(message.msg.hello, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.SyncStep sync_step = 2; */
+        if (message.msg.oneofKind === "syncStep")
+            SyncStep.internalBinaryWrite(message.msg.syncStep, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.YjsUpdate yjs_update = 3; */
+        if (message.msg.oneofKind === "yjsUpdate")
+            YjsUpdate.internalBinaryWrite(message.msg.yjsUpdate, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.AwarenessPing awareness = 4; */
+        if (message.msg.oneofKind === "awareness")
+            AwarenessPing.internalBinaryWrite(message.msg.awareness, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.ClientPacket
+ */
+export const ClientPacket = new ClientPacket$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CollabInit$Type extends MessageType<CollabInit> {
+    constructor() {
+        super("resources.collab.CollabInit", [
+            { no: 1, name: "target_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/, options: { "buf.validate.field": { int64: { gt: "0" } } } }
+        ]);
+    }
+    create(value?: PartialMessage<CollabInit>): CollabInit {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.targetId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<CollabInit>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CollabInit): CollabInit {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 target_id */ 1:
+                    message.targetId = reader.int64().toNumber();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: CollabInit, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 target_id = 1; */
+        if (message.targetId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.targetId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.CollabInit
+ */
+export const CollabInit = new CollabInit$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SyncStep$Type extends MessageType<SyncStep> {
+    constructor() {
+        super("resources.collab.SyncStep", [
+            { no: 1, name: "step", kind: "scalar", T: 5 /*ScalarType.INT32*/, options: { "buf.validate.field": { int32: { in: [1, 2] } } } },
+            { no: 2, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "receiver_id", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 2 /*LongType.NUMBER*/, options: { "buf.validate.field": { uint64: { gt: "0" } } } }
+        ]);
+    }
+    create(value?: PartialMessage<SyncStep>): SyncStep {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.step = 0;
+        message.data = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<SyncStep>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SyncStep): SyncStep {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 step */ 1:
+                    message.step = reader.int32();
+                    break;
+                case /* bytes data */ 2:
+                    message.data = reader.bytes();
+                    break;
+                case /* optional uint64 receiver_id */ 3:
+                    message.receiverId = reader.uint64().toNumber();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: SyncStep, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 step = 1; */
+        if (message.step !== 0)
+            writer.tag(1, WireType.Varint).int32(message.step);
+        /* bytes data = 2; */
+        if (message.data.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.data);
+        /* optional uint64 receiver_id = 3; */
+        if (message.receiverId !== undefined)
+            writer.tag(3, WireType.Varint).uint64(message.receiverId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.SyncStep
+ */
+export const SyncStep = new SyncStep$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class YjsUpdate$Type extends MessageType<YjsUpdate> {
+    constructor() {
+        super("resources.collab.YjsUpdate", [
+            { no: 1, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<YjsUpdate>): YjsUpdate {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.data = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<YjsUpdate>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: YjsUpdate): YjsUpdate {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes data */ 1:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: YjsUpdate, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes data = 1; */
+        if (message.data.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.data);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.YjsUpdate
+ */
+export const YjsUpdate = new YjsUpdate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AwarenessPing$Type extends MessageType<AwarenessPing> {
+    constructor() {
+        super("resources.collab.AwarenessPing", [
+            { no: 1, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<AwarenessPing>): AwarenessPing {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.data = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial<AwarenessPing>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AwarenessPing): AwarenessPing {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes data */ 1:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: AwarenessPing, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes data = 1; */
+        if (message.data.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.data);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.AwarenessPing
+ */
+export const AwarenessPing = new AwarenessPing$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerPacket$Type extends MessageType<ServerPacket> {
+    constructor() {
+        super("resources.collab.ServerPacket", [
+            { no: 1, name: "sender_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 2 /*LongType.NUMBER*/, options: { "buf.validate.field": { uint64: { gt: "0" } } } },
+            { no: 2, name: "handshake", kind: "message", oneof: "msg", T: () => CollabHandshake },
+            { no: 3, name: "sync_step", kind: "message", oneof: "msg", T: () => SyncStep },
+            { no: 4, name: "yjs_update", kind: "message", oneof: "msg", T: () => YjsUpdate },
+            { no: 5, name: "awareness", kind: "message", oneof: "msg", T: () => AwarenessPing },
+            { no: 6, name: "target_saved", kind: "message", oneof: "msg", T: () => TargetSaved },
+            { no: 7, name: "promote", kind: "message", oneof: "msg", T: () => FirstPromote },
+            { no: 8, name: "client_update", kind: "message", oneof: "msg", T: () => ClientUpdate }
+        ]);
+    }
+    create(value?: PartialMessage<ServerPacket>): ServerPacket {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.senderId = 0;
+        message.msg = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<ServerPacket>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ServerPacket): ServerPacket {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 sender_id */ 1:
+                    message.senderId = reader.uint64().toNumber();
+                    break;
+                case /* resources.collab.CollabHandshake handshake */ 2:
+                    message.msg = {
+                        oneofKind: "handshake",
+                        handshake: CollabHandshake.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).handshake)
+                    };
+                    break;
+                case /* resources.collab.SyncStep sync_step */ 3:
+                    message.msg = {
+                        oneofKind: "syncStep",
+                        syncStep: SyncStep.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).syncStep)
+                    };
+                    break;
+                case /* resources.collab.YjsUpdate yjs_update */ 4:
+                    message.msg = {
+                        oneofKind: "yjsUpdate",
+                        yjsUpdate: YjsUpdate.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).yjsUpdate)
+                    };
+                    break;
+                case /* resources.collab.AwarenessPing awareness */ 5:
+                    message.msg = {
+                        oneofKind: "awareness",
+                        awareness: AwarenessPing.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).awareness)
+                    };
+                    break;
+                case /* resources.collab.TargetSaved target_saved */ 6:
+                    message.msg = {
+                        oneofKind: "targetSaved",
+                        targetSaved: TargetSaved.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).targetSaved)
+                    };
+                    break;
+                case /* resources.collab.FirstPromote promote */ 7:
+                    message.msg = {
+                        oneofKind: "promote",
+                        promote: FirstPromote.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).promote)
+                    };
+                    break;
+                case /* resources.collab.ClientUpdate client_update */ 8:
+                    message.msg = {
+                        oneofKind: "clientUpdate",
+                        clientUpdate: ClientUpdate.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).clientUpdate)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ServerPacket, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint64 sender_id = 1; */
+        if (message.senderId !== 0)
+            writer.tag(1, WireType.Varint).uint64(message.senderId);
+        /* resources.collab.CollabHandshake handshake = 2; */
+        if (message.msg.oneofKind === "handshake")
+            CollabHandshake.internalBinaryWrite(message.msg.handshake, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.SyncStep sync_step = 3; */
+        if (message.msg.oneofKind === "syncStep")
+            SyncStep.internalBinaryWrite(message.msg.syncStep, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.YjsUpdate yjs_update = 4; */
+        if (message.msg.oneofKind === "yjsUpdate")
+            YjsUpdate.internalBinaryWrite(message.msg.yjsUpdate, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.AwarenessPing awareness = 5; */
+        if (message.msg.oneofKind === "awareness")
+            AwarenessPing.internalBinaryWrite(message.msg.awareness, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.TargetSaved target_saved = 6; */
+        if (message.msg.oneofKind === "targetSaved")
+            TargetSaved.internalBinaryWrite(message.msg.targetSaved, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.FirstPromote promote = 7; */
+        if (message.msg.oneofKind === "promote")
+            FirstPromote.internalBinaryWrite(message.msg.promote, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* resources.collab.ClientUpdate client_update = 8; */
+        if (message.msg.oneofKind === "clientUpdate")
+            ClientUpdate.internalBinaryWrite(message.msg.clientUpdate, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.ServerPacket
+ */
+export const ServerPacket = new ServerPacket$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CollabHandshake$Type extends MessageType<CollabHandshake> {
+    constructor() {
+        super("resources.collab.CollabHandshake", [
+            { no: 1, name: "client_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "first", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<CollabHandshake>): CollabHandshake {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.clientId = 0;
+        message.first = false;
+        if (value !== undefined)
+            reflectionMergePartial<CollabHandshake>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CollabHandshake): CollabHandshake {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 client_id */ 1:
+                    message.clientId = reader.uint64().toNumber();
+                    break;
+                case /* bool first */ 2:
+                    message.first = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: CollabHandshake, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint64 client_id = 1; */
+        if (message.clientId !== 0)
+            writer.tag(1, WireType.Varint).uint64(message.clientId);
+        /* bool first = 2; */
+        if (message.first !== false)
+            writer.tag(2, WireType.Varint).bool(message.first);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.CollabHandshake
+ */
+export const CollabHandshake = new CollabHandshake$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TargetSaved$Type extends MessageType<TargetSaved> {
+    constructor() {
+        super("resources.collab.TargetSaved", [
+            { no: 1, name: "target_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/, options: { "buf.validate.field": { int64: { gt: "0" } } } }
+        ]);
+    }
+    create(value?: PartialMessage<TargetSaved>): TargetSaved {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.targetId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<TargetSaved>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TargetSaved): TargetSaved {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 target_id */ 1:
+                    message.targetId = reader.int64().toNumber();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: TargetSaved, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 target_id = 1; */
+        if (message.targetId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.targetId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.TargetSaved
+ */
+export const TargetSaved = new TargetSaved$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FirstPromote$Type extends MessageType<FirstPromote> {
+    constructor() {
+        super("resources.collab.FirstPromote", []);
+    }
+    create(value?: PartialMessage<FirstPromote>): FirstPromote {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<FirstPromote>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FirstPromote): FirstPromote {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: FirstPromote, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.FirstPromote
+ */
+export const FirstPromote = new FirstPromote$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClientUpdate$Type extends MessageType<ClientUpdate> {
+    constructor() {
+        super("resources.collab.ClientUpdate", [
+            { no: 1, name: "joined", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "client_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 2 /*LongType.NUMBER*/, options: { "buf.validate.field": { uint64: { gt: "0" } } } },
+            { no: 3, name: "label", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxLen: "128" } } } }
+        ]);
+    }
+    create(value?: PartialMessage<ClientUpdate>): ClientUpdate {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.joined = false;
+        message.clientId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ClientUpdate>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClientUpdate): ClientUpdate {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool joined */ 1:
+                    message.joined = reader.bool();
+                    break;
+                case /* uint64 client_id */ 2:
+                    message.clientId = reader.uint64().toNumber();
+                    break;
+                case /* optional string label */ 3:
+                    message.label = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ClientUpdate, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bool joined = 1; */
+        if (message.joined !== false)
+            writer.tag(1, WireType.Varint).bool(message.joined);
+        /* uint64 client_id = 2; */
+        if (message.clientId !== 0)
+            writer.tag(2, WireType.Varint).uint64(message.clientId);
+        /* optional string label = 3; */
+        if (message.label !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.label);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.collab.ClientUpdate
+ */
+export const ClientUpdate = new ClientUpdate$Type();