From 6e3553596bab4f190b1f73fa510f9fb3c8167685 Mon Sep 17 00:00:00 2001 From: Matthew Cotton Date: Tue, 30 Jan 2024 14:36:24 +1100 Subject: [PATCH] Adding built protobuf stuff and related helpers etc. --- Common/package-lock.json | 143 +- Common/package.json | 5 + Common/src/Messages/base_message.ts | 3 + Common/src/Messages/message_helpers.ts | 11 + Common/src/Messages/message_registry.ts | 28 + Common/src/Messages/signalling_messages.ts | 1774 ++++++++++++++++++++ Common/src/pixelstreamingcommon.ts | 8 +- 7 files changed, 1955 insertions(+), 17 deletions(-) create mode 100644 Common/src/Messages/base_message.ts create mode 100644 Common/src/Messages/message_helpers.ts create mode 100644 Common/src/Messages/message_registry.ts create mode 100644 Common/src/Messages/signalling_messages.ts diff --git a/Common/package-lock.json b/Common/package-lock.json index f7d14a4f..ebda9107 100644 --- a/Common/package-lock.json +++ b/Common/package-lock.json @@ -1,15 +1,17 @@ { "name": "@epicgames-ps/lib-pixelstreamingcommon-ue5.5", - "version": "0.0.1", + "version": "0.0.4", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "@epicgames-ps/lib-pixelstreamingcommon-ue5.5", - "version": "0.0.1", + "version": "0.0.4", "license": "MIT", + "dependencies": { + "@protobuf-ts/plugin": "^2.9.3" + }, "devDependencies": { - "@types/events": "^3.0.3", "@types/jest": "27.5.1", "@types/webxr": "^0.5.1", "@typescript-eslint/eslint-plugin": "^5.16.0", @@ -1407,6 +1409,76 @@ "node": ">= 8" } }, + "node_modules/@protobuf-ts/plugin": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/plugin/-/plugin-2.9.3.tgz", + "integrity": "sha512-tHYACv+nnIV2eoiMxeZhrgMqGiUktzUzrhfgnROg/rr8TecPLp9v5/yqNibN+bad5k7d57aqlTuQKhFl+J4W/g==", + "dependencies": { + "@protobuf-ts/plugin-framework": "^2.9.3", + "@protobuf-ts/protoc": "^2.9.3", + "@protobuf-ts/runtime": "^2.9.3", + "@protobuf-ts/runtime-rpc": "^2.9.3", + "typescript": "^3.9" + }, + "bin": { + "protoc-gen-dump": "bin/protoc-gen-dump", + "protoc-gen-ts": "bin/protoc-gen-ts" + } + }, + "node_modules/@protobuf-ts/plugin-framework": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/plugin-framework/-/plugin-framework-2.9.3.tgz", + "integrity": "sha512-iqdkhAu7fGPvBCVOoAEEFJ1/oaGIBoNIMgSv2WonTNJVHxv5FvvAfWFn6nG/eta34fHRZT38ZXTaYcMUkv8AiQ==", + "dependencies": { + "@protobuf-ts/runtime": "^2.9.3", + "typescript": "^3.9" + } + }, + "node_modules/@protobuf-ts/plugin-framework/node_modules/typescript": { + "version": "3.9.10", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.10.tgz", + "integrity": "sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/@protobuf-ts/plugin/node_modules/typescript": { + "version": "3.9.10", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.10.tgz", + "integrity": "sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/@protobuf-ts/protoc": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/protoc/-/protoc-2.9.3.tgz", + "integrity": "sha512-TJ0Ycx/CIBqpB4wpKt6K05kjXj6zv36s/qpdCT/wdJBhpayOVBqLF5NpLp3WIiw1PmIxvqalB6QHKjvnLzGKLA==", + "bin": { + "protoc": "protoc.js" + } + }, + "node_modules/@protobuf-ts/runtime": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.9.3.tgz", + "integrity": "sha512-nivzCpg/qYD0RX2OmHOahJALb8ndjGmUhNBcTJ0BbXoqKwCSM6vYA+vegzS3rhuaPgbyC7Ec8idlnizzUfIRuw==" + }, + "node_modules/@protobuf-ts/runtime-rpc": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime-rpc/-/runtime-rpc-2.9.3.tgz", + "integrity": "sha512-WelHpctvZeG8yhbb7tnsrLzotq9xjMCXuGuhJ8qMyEdNoBBEodbXseofAYFTebo2/PN2LzyEq3X6vwr5f8jqTA==", + "dependencies": { + "@protobuf-ts/runtime": "^2.9.3" + } + }, "node_modules/@sinonjs/commons": { "version": "1.8.6", "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.6.tgz", @@ -1504,12 +1576,6 @@ "dev": true, "peer": true }, - "node_modules/@types/events": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@types/events/-/events-3.0.3.tgz", - "integrity": "sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==", - "dev": true - }, "node_modules/@types/graceful-fs": { "version": "4.1.9", "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.9.tgz", @@ -7729,6 +7795,59 @@ "fastq": "^1.6.0" } }, + "@protobuf-ts/plugin": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/plugin/-/plugin-2.9.3.tgz", + "integrity": "sha512-tHYACv+nnIV2eoiMxeZhrgMqGiUktzUzrhfgnROg/rr8TecPLp9v5/yqNibN+bad5k7d57aqlTuQKhFl+J4W/g==", + "requires": { + "@protobuf-ts/plugin-framework": "^2.9.3", + "@protobuf-ts/protoc": "^2.9.3", + "@protobuf-ts/runtime": "^2.9.3", + "@protobuf-ts/runtime-rpc": "^2.9.3", + "typescript": "^3.9" + }, + "dependencies": { + "typescript": { + "version": "3.9.10", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.10.tgz", + "integrity": "sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==" + } + } + }, + "@protobuf-ts/plugin-framework": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/plugin-framework/-/plugin-framework-2.9.3.tgz", + "integrity": "sha512-iqdkhAu7fGPvBCVOoAEEFJ1/oaGIBoNIMgSv2WonTNJVHxv5FvvAfWFn6nG/eta34fHRZT38ZXTaYcMUkv8AiQ==", + "requires": { + "@protobuf-ts/runtime": "^2.9.3", + "typescript": "^3.9" + }, + "dependencies": { + "typescript": { + "version": "3.9.10", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.10.tgz", + "integrity": "sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==" + } + } + }, + "@protobuf-ts/protoc": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/protoc/-/protoc-2.9.3.tgz", + "integrity": "sha512-TJ0Ycx/CIBqpB4wpKt6K05kjXj6zv36s/qpdCT/wdJBhpayOVBqLF5NpLp3WIiw1PmIxvqalB6QHKjvnLzGKLA==" + }, + "@protobuf-ts/runtime": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.9.3.tgz", + "integrity": "sha512-nivzCpg/qYD0RX2OmHOahJALb8ndjGmUhNBcTJ0BbXoqKwCSM6vYA+vegzS3rhuaPgbyC7Ec8idlnizzUfIRuw==" + }, + "@protobuf-ts/runtime-rpc": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime-rpc/-/runtime-rpc-2.9.3.tgz", + "integrity": "sha512-WelHpctvZeG8yhbb7tnsrLzotq9xjMCXuGuhJ8qMyEdNoBBEodbXseofAYFTebo2/PN2LzyEq3X6vwr5f8jqTA==", + "requires": { + "@protobuf-ts/runtime": "^2.9.3" + } + }, "@sinonjs/commons": { "version": "1.8.6", "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.6.tgz", @@ -7823,12 +7942,6 @@ "dev": true, "peer": true }, - "@types/events": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@types/events/-/events-3.0.3.tgz", - "integrity": "sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==", - "dev": true - }, "@types/graceful-fs": { "version": "4.1.9", "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.9.tgz", diff --git a/Common/package.json b/Common/package.json index 3ec63332..ce945e0f 100644 --- a/Common/package.json +++ b/Common/package.json @@ -6,8 +6,10 @@ "types": "types/pixelstreamingcommon.d.ts", "sideEffects": false, "scripts": { + "build_proto": "npx protoc --ts_out src/Messages --proto_path protobuf protobuf/signalling_messages.proto", "compile": "tsc --build --clean && tsc", "build": "tsc --build --clean && tsc", + "build-all": "npm run build_proto && npm run build", "test": "echo \"Error: no test specified\" && exit 1", "lint": "eslint . --ext .js,.jsx,.ts,.tsx" }, @@ -30,5 +32,8 @@ "license": "MIT", "publishConfig": { "access": "public" + }, + "dependencies": { + "@protobuf-ts/plugin": "^2.9.3" } } diff --git a/Common/src/Messages/base_message.ts b/Common/src/Messages/base_message.ts new file mode 100644 index 00000000..2471fb68 --- /dev/null +++ b/Common/src/Messages/base_message.ts @@ -0,0 +1,3 @@ +export interface BaseMessage { + type: string; +} diff --git a/Common/src/Messages/message_helpers.ts b/Common/src/Messages/message_helpers.ts new file mode 100644 index 00000000..fbe86a01 --- /dev/null +++ b/Common/src/Messages/message_helpers.ts @@ -0,0 +1,11 @@ +import { IMessageType } from "@protobuf-ts/runtime"; +import { BaseMessage } from './base_message'; + +export function createMessage(messageType: IMessageType, params?: any) { + const message = messageType.create(); + message.type = messageType.typeName; + if (params) { + messageType.mergePartial(message, params); + } + return message; +} diff --git a/Common/src/Messages/message_registry.ts b/Common/src/Messages/message_registry.ts new file mode 100644 index 00000000..44f4f279 --- /dev/null +++ b/Common/src/Messages/message_registry.ts @@ -0,0 +1,28 @@ +import { IMessageType } from "@protobuf-ts/runtime"; +import * as Messages from './signalling_messages'; +import { BaseMessage } from './base_message'; + +export const MessageRegistry: Record> = { + 'answer': Messages.answer, + 'config': Messages.config, + 'dataChannelRequest': Messages.dataChannelRequest, + 'disconnectPlayer': Messages.disconnectPlayer, + 'endpointId': Messages.endpointId, + 'iceCandidate': Messages.iceCandidate, + 'identify': Messages.identify, + 'layerPreference': Messages.layerPreference, + 'listStreamers': Messages.listStreamers, + 'offer': Messages.offer, + 'peerDataChannelsReady': Messages.peerDataChannelsReady, + 'ping': Messages.ping, + 'playerConnected': Messages.playerConnected, + 'playerCount': Messages.playerCount, + 'playerDisconnected': Messages.playerDisconnected, + 'pong': Messages.pong, + 'stats': Messages.stats, + 'streamerDataChannels': Messages.streamerDataChannels, + 'streamerDisconnected': Messages.streamerDisconnected, + 'streamerList': Messages.streamerList, + 'subscribe': Messages.subscribe, + 'unsubscribe': Messages.unsubscribe, +} diff --git a/Common/src/Messages/signalling_messages.ts b/Common/src/Messages/signalling_messages.ts new file mode 100644 index 00000000..424a4291 --- /dev/null +++ b/Common/src/Messages/signalling_messages.ts @@ -0,0 +1,1774 @@ +// @generated by protobuf-ts 2.9.3 +// @generated from protobuf file "signalling_messages.proto" (syntax proto3) +// tslint:disable +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"; +/** + * intermediate message to determine message type + * + * @generated from protobuf message base_message + */ +export interface base_message { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; +} +/** + * @generated from protobuf message answer + */ +export interface answer { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string sdp = 2; + */ + sdp: string; + /** + * @generated from protobuf field: optional string playerId = 3; + */ + playerId?: string; +} +/** + * @generated from protobuf message peerConnectionOptions + */ +export interface peerConnectionOptions { +} +/** + * @generated from protobuf message config + */ +export interface config { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: peerConnectionOptions peerConnectionOptions = 2; + */ + peerConnectionOptions?: peerConnectionOptions; + /** + * @generated from protobuf field: optional string protocolVersion = 3; + */ + protocolVersion?: string; +} +/** + * @generated from protobuf message dataChannelRequest + */ +export interface dataChannelRequest { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; +} +/** + * @generated from protobuf message disconnectPlayer + */ +export interface disconnectPlayer { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string playerId = 2; + */ + playerId: string; + /** + * @generated from protobuf field: optional string reason = 3; + */ + reason?: string; +} +/** + * @generated from protobuf message endpointId + */ +export interface endpointId { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string id = 2; + */ + id: string; + /** + * @generated from protobuf field: optional string protocolVersion = 3; + */ + protocolVersion?: string; +} +/** + * @generated from protobuf message iceCandidateData + */ +export interface iceCandidateData { + /** + * @generated from protobuf field: string candidate = 1; + */ + candidate: string; + /** + * @generated from protobuf field: string sdpMid = 2; + */ + sdpMid: string; + /** + * @generated from protobuf field: int32 sdpMLineIndex = 3; + */ + sdpMLineIndex: number; + /** + * @generated from protobuf field: optional string usernameFragment = 4; + */ + usernameFragment?: string; +} +/** + * @generated from protobuf message iceCandidate + */ +export interface iceCandidate { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: iceCandidateData candidate = 2; + */ + candidate?: iceCandidateData; + /** + * @generated from protobuf field: optional string playerId = 3; + */ + playerId?: string; +} +/** + * @generated from protobuf message identify + */ +export interface identify { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; +} +/** + * @generated from protobuf message layerPreference + */ +export interface layerPreference { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: int32 spatialLayer = 2; + */ + spatialLayer: number; + /** + * @generated from protobuf field: int32 temporalLayer = 3; + */ + temporalLayer: number; + /** + * @generated from protobuf field: string playerId = 4; + */ + playerId: string; +} +/** + * @generated from protobuf message listStreamers + */ +export interface listStreamers { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; +} +/** + * @generated from protobuf message offer + */ +export interface offer { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string sdp = 2; + */ + sdp: string; + /** + * @generated from protobuf field: optional string playerId = 3; + */ + playerId?: string; +} +/** + * @generated from protobuf message peerDataChannelsReady + */ +export interface peerDataChannelsReady { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; +} +/** + * @generated from protobuf message ping + */ +export interface ping { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: int32 time = 2; + */ + time: number; +} +/** + * @generated from protobuf message playerConnected + */ +export interface playerConnected { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: bool dataChannel = 2; + */ + dataChannel: boolean; + /** + * @generated from protobuf field: bool sfu = 3; + */ + sfu: boolean; + /** + * @generated from protobuf field: bool sendOffer = 4; + */ + sendOffer: boolean; + /** + * @generated from protobuf field: optional string playerId = 5; + */ + playerId?: string; +} +/** + * @generated from protobuf message playerCount + */ +export interface playerCount { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: int32 count = 2; + */ + count: number; +} +/** + * @generated from protobuf message playerDisconnected + */ +export interface playerDisconnected { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string playerId = 2; + */ + playerId: string; +} +/** + * @generated from protobuf message pong + */ +export interface pong { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: int32 time = 2; + */ + time: number; +} +/** + * @generated from protobuf message stats + */ +export interface stats { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string data = 2; + */ + data: string; +} +/** + * @generated from protobuf message streamerDataChannels + */ +export interface streamerDataChannels { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: int32 sendStreamId = 2; + */ + sendStreamId: number; + /** + * @generated from protobuf field: int32 recvStreamId = 3; + */ + recvStreamId: number; + /** + * @generated from protobuf field: string playerId = 4; + */ + playerId: string; +} +/** + * @generated from protobuf message streamerDisconnected + */ +export interface streamerDisconnected { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string streamerId = 2; + */ + streamerId: string; // NEW +} +/** + * @generated from protobuf message streamerList + */ +export interface streamerList { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: repeated string ids = 2; + */ + ids: string[]; // CHECK +} +/** + * @generated from protobuf message subscribe + */ +export interface subscribe { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; + /** + * @generated from protobuf field: string streamerId = 2; + */ + streamerId: string; +} +/** + * @generated from protobuf message unsubscribe + */ +export interface unsubscribe { + /** + * @generated from protobuf field: string type = 1; + */ + type: string; +} +// @generated message type with reflection information, may provide speed optimized methods +class base_message$Type extends MessageType { + constructor() { + super("base_message", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): base_message { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: base_message): base_message { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = 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: base_message, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message base_message + */ +export const base_message = new base_message$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class answer$Type extends MessageType { + constructor() { + super("answer", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "sdp", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "playerId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): answer { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.sdp = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: answer): answer { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string sdp */ 2: + message.sdp = reader.string(); + break; + case /* optional string playerId */ 3: + message.playerId = 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: answer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string sdp = 2; */ + if (message.sdp !== "") + writer.tag(2, WireType.LengthDelimited).string(message.sdp); + /* optional string playerId = 3; */ + if (message.playerId !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.playerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message answer + */ +export const answer = new answer$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class peerConnectionOptions$Type extends MessageType { + constructor() { + super("peerConnectionOptions", []); + } + create(value?: PartialMessage): peerConnectionOptions { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: peerConnectionOptions): peerConnectionOptions { + return target ?? this.create(); + } + internalBinaryWrite(message: peerConnectionOptions, 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 peerConnectionOptions + */ +export const peerConnectionOptions = new peerConnectionOptions$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class config$Type extends MessageType { + constructor() { + super("config", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "peerConnectionOptions", kind: "message", T: () => peerConnectionOptions }, + { no: 3, name: "protocolVersion", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): config { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: config): config { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* peerConnectionOptions peerConnectionOptions */ 2: + message.peerConnectionOptions = peerConnectionOptions.internalBinaryRead(reader, reader.uint32(), options, message.peerConnectionOptions); + break; + case /* optional string protocolVersion */ 3: + message.protocolVersion = 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: config, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* peerConnectionOptions peerConnectionOptions = 2; */ + if (message.peerConnectionOptions) + peerConnectionOptions.internalBinaryWrite(message.peerConnectionOptions, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* optional string protocolVersion = 3; */ + if (message.protocolVersion !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.protocolVersion); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message config + */ +export const config = new config$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class dataChannelRequest$Type extends MessageType { + constructor() { + super("dataChannelRequest", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): dataChannelRequest { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: dataChannelRequest): dataChannelRequest { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = 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: dataChannelRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message dataChannelRequest + */ +export const dataChannelRequest = new dataChannelRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class disconnectPlayer$Type extends MessageType { + constructor() { + super("disconnectPlayer", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "playerId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): disconnectPlayer { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.playerId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: disconnectPlayer): disconnectPlayer { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string playerId */ 2: + message.playerId = reader.string(); + break; + case /* optional string reason */ 3: + message.reason = 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: disconnectPlayer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string playerId = 2; */ + if (message.playerId !== "") + writer.tag(2, WireType.LengthDelimited).string(message.playerId); + /* optional string reason = 3; */ + if (message.reason !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.reason); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message disconnectPlayer + */ +export const disconnectPlayer = new disconnectPlayer$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class endpointId$Type extends MessageType { + constructor() { + super("endpointId", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "protocolVersion", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): endpointId { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.id = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: endpointId): endpointId { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string id */ 2: + message.id = reader.string(); + break; + case /* optional string protocolVersion */ 3: + message.protocolVersion = 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: endpointId, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string id = 2; */ + if (message.id !== "") + writer.tag(2, WireType.LengthDelimited).string(message.id); + /* optional string protocolVersion = 3; */ + if (message.protocolVersion !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.protocolVersion); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message endpointId + */ +export const endpointId = new endpointId$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class iceCandidateData$Type extends MessageType { + constructor() { + super("iceCandidateData", [ + { no: 1, name: "candidate", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "sdpMid", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "sdpMLineIndex", kind: "scalar", T: 5 /*ScalarType.INT32*/ }, + { no: 4, name: "usernameFragment", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): iceCandidateData { + const message = globalThis.Object.create((this.messagePrototype!)); + message.candidate = ""; + message.sdpMid = ""; + message.sdpMLineIndex = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: iceCandidateData): iceCandidateData { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string candidate */ 1: + message.candidate = reader.string(); + break; + case /* string sdpMid */ 2: + message.sdpMid = reader.string(); + break; + case /* int32 sdpMLineIndex */ 3: + message.sdpMLineIndex = reader.int32(); + break; + case /* optional string usernameFragment */ 4: + message.usernameFragment = 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: iceCandidateData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string candidate = 1; */ + if (message.candidate !== "") + writer.tag(1, WireType.LengthDelimited).string(message.candidate); + /* string sdpMid = 2; */ + if (message.sdpMid !== "") + writer.tag(2, WireType.LengthDelimited).string(message.sdpMid); + /* int32 sdpMLineIndex = 3; */ + if (message.sdpMLineIndex !== 0) + writer.tag(3, WireType.Varint).int32(message.sdpMLineIndex); + /* optional string usernameFragment = 4; */ + if (message.usernameFragment !== undefined) + writer.tag(4, WireType.LengthDelimited).string(message.usernameFragment); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message iceCandidateData + */ +export const iceCandidateData = new iceCandidateData$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class iceCandidate$Type extends MessageType { + constructor() { + super("iceCandidate", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "candidate", kind: "message", T: () => iceCandidateData }, + { no: 3, name: "playerId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): iceCandidate { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: iceCandidate): iceCandidate { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* iceCandidateData candidate */ 2: + message.candidate = iceCandidateData.internalBinaryRead(reader, reader.uint32(), options, message.candidate); + break; + case /* optional string playerId */ 3: + message.playerId = 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: iceCandidate, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* iceCandidateData candidate = 2; */ + if (message.candidate) + iceCandidateData.internalBinaryWrite(message.candidate, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* optional string playerId = 3; */ + if (message.playerId !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.playerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message iceCandidate + */ +export const iceCandidate = new iceCandidate$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class identify$Type extends MessageType { + constructor() { + super("identify", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): identify { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: identify): identify { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = 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: identify, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message identify + */ +export const identify = new identify$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class layerPreference$Type extends MessageType { + constructor() { + super("layerPreference", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "spatialLayer", kind: "scalar", T: 5 /*ScalarType.INT32*/ }, + { no: 3, name: "temporalLayer", kind: "scalar", T: 5 /*ScalarType.INT32*/ }, + { no: 4, name: "playerId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): layerPreference { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.spatialLayer = 0; + message.temporalLayer = 0; + message.playerId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: layerPreference): layerPreference { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* int32 spatialLayer */ 2: + message.spatialLayer = reader.int32(); + break; + case /* int32 temporalLayer */ 3: + message.temporalLayer = reader.int32(); + break; + case /* string playerId */ 4: + message.playerId = 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: layerPreference, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* int32 spatialLayer = 2; */ + if (message.spatialLayer !== 0) + writer.tag(2, WireType.Varint).int32(message.spatialLayer); + /* int32 temporalLayer = 3; */ + if (message.temporalLayer !== 0) + writer.tag(3, WireType.Varint).int32(message.temporalLayer); + /* string playerId = 4; */ + if (message.playerId !== "") + writer.tag(4, WireType.LengthDelimited).string(message.playerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message layerPreference + */ +export const layerPreference = new layerPreference$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class listStreamers$Type extends MessageType { + constructor() { + super("listStreamers", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): listStreamers { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: listStreamers): listStreamers { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = 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: listStreamers, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message listStreamers + */ +export const listStreamers = new listStreamers$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class offer$Type extends MessageType { + constructor() { + super("offer", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "sdp", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "playerId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): offer { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.sdp = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: offer): offer { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string sdp */ 2: + message.sdp = reader.string(); + break; + case /* optional string playerId */ 3: + message.playerId = 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: offer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string sdp = 2; */ + if (message.sdp !== "") + writer.tag(2, WireType.LengthDelimited).string(message.sdp); + /* optional string playerId = 3; */ + if (message.playerId !== undefined) + writer.tag(3, WireType.LengthDelimited).string(message.playerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message offer + */ +export const offer = new offer$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class peerDataChannelsReady$Type extends MessageType { + constructor() { + super("peerDataChannelsReady", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): peerDataChannelsReady { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: peerDataChannelsReady): peerDataChannelsReady { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = 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: peerDataChannelsReady, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message peerDataChannelsReady + */ +export const peerDataChannelsReady = new peerDataChannelsReady$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ping$Type extends MessageType { + constructor() { + super("ping", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "time", kind: "scalar", T: 5 /*ScalarType.INT32*/ } + ]); + } + create(value?: PartialMessage): ping { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.time = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ping): ping { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* int32 time */ 2: + message.time = reader.int32(); + 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: ping, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* int32 time = 2; */ + if (message.time !== 0) + writer.tag(2, WireType.Varint).int32(message.time); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message ping + */ +export const ping = new ping$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class playerConnected$Type extends MessageType { + constructor() { + super("playerConnected", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "dataChannel", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 3, name: "sfu", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 4, name: "sendOffer", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 5, name: "playerId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): playerConnected { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.dataChannel = false; + message.sfu = false; + message.sendOffer = false; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: playerConnected): playerConnected { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* bool dataChannel */ 2: + message.dataChannel = reader.bool(); + break; + case /* bool sfu */ 3: + message.sfu = reader.bool(); + break; + case /* bool sendOffer */ 4: + message.sendOffer = reader.bool(); + break; + case /* optional string playerId */ 5: + message.playerId = 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: playerConnected, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* bool dataChannel = 2; */ + if (message.dataChannel !== false) + writer.tag(2, WireType.Varint).bool(message.dataChannel); + /* bool sfu = 3; */ + if (message.sfu !== false) + writer.tag(3, WireType.Varint).bool(message.sfu); + /* bool sendOffer = 4; */ + if (message.sendOffer !== false) + writer.tag(4, WireType.Varint).bool(message.sendOffer); + /* optional string playerId = 5; */ + if (message.playerId !== undefined) + writer.tag(5, WireType.LengthDelimited).string(message.playerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message playerConnected + */ +export const playerConnected = new playerConnected$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class playerCount$Type extends MessageType { + constructor() { + super("playerCount", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "count", kind: "scalar", T: 5 /*ScalarType.INT32*/ } + ]); + } + create(value?: PartialMessage): playerCount { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.count = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: playerCount): playerCount { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* int32 count */ 2: + message.count = reader.int32(); + 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: playerCount, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* int32 count = 2; */ + if (message.count !== 0) + writer.tag(2, WireType.Varint).int32(message.count); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message playerCount + */ +export const playerCount = new playerCount$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class playerDisconnected$Type extends MessageType { + constructor() { + super("playerDisconnected", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "playerId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): playerDisconnected { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.playerId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: playerDisconnected): playerDisconnected { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string playerId */ 2: + message.playerId = 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: playerDisconnected, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string playerId = 2; */ + if (message.playerId !== "") + writer.tag(2, WireType.LengthDelimited).string(message.playerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message playerDisconnected + */ +export const playerDisconnected = new playerDisconnected$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class pong$Type extends MessageType { + constructor() { + super("pong", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "time", kind: "scalar", T: 5 /*ScalarType.INT32*/ } + ]); + } + create(value?: PartialMessage): pong { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.time = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: pong): pong { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* int32 time */ 2: + message.time = reader.int32(); + 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: pong, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* int32 time = 2; */ + if (message.time !== 0) + writer.tag(2, WireType.Varint).int32(message.time); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message pong + */ +export const pong = new pong$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class stats$Type extends MessageType { + constructor() { + super("stats", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "data", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): stats { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.data = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: stats): stats { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string data */ 2: + message.data = 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: stats, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string data = 2; */ + if (message.data !== "") + writer.tag(2, WireType.LengthDelimited).string(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 stats + */ +export const stats = new stats$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class streamerDataChannels$Type extends MessageType { + constructor() { + super("streamerDataChannels", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "sendStreamId", kind: "scalar", T: 5 /*ScalarType.INT32*/ }, + { no: 3, name: "recvStreamId", kind: "scalar", T: 5 /*ScalarType.INT32*/ }, + { no: 4, name: "playerId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): streamerDataChannels { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.sendStreamId = 0; + message.recvStreamId = 0; + message.playerId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: streamerDataChannels): streamerDataChannels { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* int32 sendStreamId */ 2: + message.sendStreamId = reader.int32(); + break; + case /* int32 recvStreamId */ 3: + message.recvStreamId = reader.int32(); + break; + case /* string playerId */ 4: + message.playerId = 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: streamerDataChannels, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* int32 sendStreamId = 2; */ + if (message.sendStreamId !== 0) + writer.tag(2, WireType.Varint).int32(message.sendStreamId); + /* int32 recvStreamId = 3; */ + if (message.recvStreamId !== 0) + writer.tag(3, WireType.Varint).int32(message.recvStreamId); + /* string playerId = 4; */ + if (message.playerId !== "") + writer.tag(4, WireType.LengthDelimited).string(message.playerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message streamerDataChannels + */ +export const streamerDataChannels = new streamerDataChannels$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class streamerDisconnected$Type extends MessageType { + constructor() { + super("streamerDisconnected", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "streamerId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): streamerDisconnected { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.streamerId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: streamerDisconnected): streamerDisconnected { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string streamerId */ 2: + message.streamerId = 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: streamerDisconnected, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string streamerId = 2; */ + if (message.streamerId !== "") + writer.tag(2, WireType.LengthDelimited).string(message.streamerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message streamerDisconnected + */ +export const streamerDisconnected = new streamerDisconnected$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class streamerList$Type extends MessageType { + constructor() { + super("streamerList", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "ids", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): streamerList { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.ids = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: streamerList): streamerList { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* repeated string ids */ 2: + message.ids.push(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: streamerList, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* repeated string ids = 2; */ + for (let i = 0; i < message.ids.length; i++) + writer.tag(2, WireType.LengthDelimited).string(message.ids[i]); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message streamerList + */ +export const streamerList = new streamerList$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class subscribe$Type extends MessageType { + constructor() { + super("subscribe", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "streamerId", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): subscribe { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + message.streamerId = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: subscribe): subscribe { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = reader.string(); + break; + case /* string streamerId */ 2: + message.streamerId = 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: subscribe, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + /* string streamerId = 2; */ + if (message.streamerId !== "") + writer.tag(2, WireType.LengthDelimited).string(message.streamerId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message subscribe + */ +export const subscribe = new subscribe$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class unsubscribe$Type extends MessageType { + constructor() { + super("unsubscribe", [ + { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): unsubscribe { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: unsubscribe): unsubscribe { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string type */ 1: + message.type = 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: unsubscribe, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string type = 1; */ + if (message.type !== "") + writer.tag(1, WireType.LengthDelimited).string(message.type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message unsubscribe + */ +export const unsubscribe = new unsubscribe$Type(); diff --git a/Common/src/pixelstreamingcommon.ts b/Common/src/pixelstreamingcommon.ts index 356d4c75..32c05092 100644 --- a/Common/src/pixelstreamingcommon.ts +++ b/Common/src/pixelstreamingcommon.ts @@ -1,8 +1,12 @@ -export { Logger } from './Logger/Logger' +export { Logger } from './Logger/Logger'; export { ITransport } from './Transport/ITransport'; export { WebSocketTransport } from './Transport/WebSocketTransport'; export { SignallingProtocol } from './WebSockets/SignallingProtocol'; export * as MessageReceive from './WebSockets/MessageReceive'; export * as MessageSend from './WebSockets/MessageSend'; export { MessageStreamerList } from './WebSockets/MessageReceive'; - +export { IMessageType } from "@protobuf-ts/runtime"; +export { BaseMessage } from './Messages/base_message'; +export { MessageRegistry } from './Messages/message_registry'; +export * as Messages from './Messages/signalling_messages'; +export * as MessageHelpers from './Messages/message_helpers';