diff --git a/package.json b/package.json
index ec6b7fac4..abe5dd151 100644
--- a/package.json
+++ b/package.json
@@ -9,5 +9,8 @@
   "devDependencies": {
     "typescript": "^4.4.4",
     "vite": "^2.7.2"
+  },
+  "dependencies": {
+    "ts-proto": "^1.101.0"
   }
 }
diff --git a/src/message.ts b/src/message.ts
new file mode 100644
index 000000000..9c0532dec
--- /dev/null
+++ b/src/message.ts
@@ -0,0 +1,4969 @@
+/* eslint-disable */
+import { util, configure, Writer, Reader } from "protobufjs/minimal";
+import * as Long from "long";
+
+export const protobufPackage = "hbb";
+
+export enum ControlKey {
+  Unknown = 0,
+  Alt = 1,
+  Backspace = 2,
+  CapsLock = 3,
+  Control = 4,
+  Delete = 5,
+  DownArrow = 6,
+  End = 7,
+  Escape = 8,
+  F1 = 9,
+  F10 = 10,
+  F11 = 11,
+  F12 = 12,
+  F2 = 13,
+  F3 = 14,
+  F4 = 15,
+  F5 = 16,
+  F6 = 17,
+  F7 = 18,
+  F8 = 19,
+  F9 = 20,
+  Home = 21,
+  LeftArrow = 22,
+  /** Meta - / meta key (also known as "windows"; "super"; and "command") */
+  Meta = 23,
+  /** Option - / option key on macOS (alt key on Linux and Windows) */
+  Option = 24,
+  PageDown = 25,
+  PageUp = 26,
+  Return = 27,
+  RightArrow = 28,
+  Shift = 29,
+  Space = 30,
+  Tab = 31,
+  UpArrow = 32,
+  Numpad0 = 33,
+  Numpad1 = 34,
+  Numpad2 = 35,
+  Numpad3 = 36,
+  Numpad4 = 37,
+  Numpad5 = 38,
+  Numpad6 = 39,
+  Numpad7 = 40,
+  Numpad8 = 41,
+  Numpad9 = 42,
+  Cancel = 43,
+  Clear = 44,
+  /** Menu - deprecated, use Alt instead */
+  Menu = 45,
+  Pause = 46,
+  Kana = 47,
+  Hangul = 48,
+  Junja = 49,
+  Final = 50,
+  Hanja = 51,
+  Kanji = 52,
+  Convert = 53,
+  Select = 54,
+  Print = 55,
+  Execute = 56,
+  Snapshot = 57,
+  Insert = 58,
+  Help = 59,
+  Sleep = 60,
+  Separator = 61,
+  Scroll = 62,
+  NumLock = 63,
+  RWin = 64,
+  Apps = 65,
+  Multiply = 66,
+  Add = 67,
+  Subtract = 68,
+  Decimal = 69,
+  Divide = 70,
+  Equals = 71,
+  NumpadEnter = 72,
+  RShift = 73,
+  RControl = 74,
+  RAlt = 75,
+  CtrlAltDel = 100,
+  LockScreen = 101,
+  UNRECOGNIZED = -1,
+}
+
+export function controlKeyFromJSON(object: any): ControlKey {
+  switch (object) {
+    case 0:
+    case "Unknown":
+      return ControlKey.Unknown;
+    case 1:
+    case "Alt":
+      return ControlKey.Alt;
+    case 2:
+    case "Backspace":
+      return ControlKey.Backspace;
+    case 3:
+    case "CapsLock":
+      return ControlKey.CapsLock;
+    case 4:
+    case "Control":
+      return ControlKey.Control;
+    case 5:
+    case "Delete":
+      return ControlKey.Delete;
+    case 6:
+    case "DownArrow":
+      return ControlKey.DownArrow;
+    case 7:
+    case "End":
+      return ControlKey.End;
+    case 8:
+    case "Escape":
+      return ControlKey.Escape;
+    case 9:
+    case "F1":
+      return ControlKey.F1;
+    case 10:
+    case "F10":
+      return ControlKey.F10;
+    case 11:
+    case "F11":
+      return ControlKey.F11;
+    case 12:
+    case "F12":
+      return ControlKey.F12;
+    case 13:
+    case "F2":
+      return ControlKey.F2;
+    case 14:
+    case "F3":
+      return ControlKey.F3;
+    case 15:
+    case "F4":
+      return ControlKey.F4;
+    case 16:
+    case "F5":
+      return ControlKey.F5;
+    case 17:
+    case "F6":
+      return ControlKey.F6;
+    case 18:
+    case "F7":
+      return ControlKey.F7;
+    case 19:
+    case "F8":
+      return ControlKey.F8;
+    case 20:
+    case "F9":
+      return ControlKey.F9;
+    case 21:
+    case "Home":
+      return ControlKey.Home;
+    case 22:
+    case "LeftArrow":
+      return ControlKey.LeftArrow;
+    case 23:
+    case "Meta":
+      return ControlKey.Meta;
+    case 24:
+    case "Option":
+      return ControlKey.Option;
+    case 25:
+    case "PageDown":
+      return ControlKey.PageDown;
+    case 26:
+    case "PageUp":
+      return ControlKey.PageUp;
+    case 27:
+    case "Return":
+      return ControlKey.Return;
+    case 28:
+    case "RightArrow":
+      return ControlKey.RightArrow;
+    case 29:
+    case "Shift":
+      return ControlKey.Shift;
+    case 30:
+    case "Space":
+      return ControlKey.Space;
+    case 31:
+    case "Tab":
+      return ControlKey.Tab;
+    case 32:
+    case "UpArrow":
+      return ControlKey.UpArrow;
+    case 33:
+    case "Numpad0":
+      return ControlKey.Numpad0;
+    case 34:
+    case "Numpad1":
+      return ControlKey.Numpad1;
+    case 35:
+    case "Numpad2":
+      return ControlKey.Numpad2;
+    case 36:
+    case "Numpad3":
+      return ControlKey.Numpad3;
+    case 37:
+    case "Numpad4":
+      return ControlKey.Numpad4;
+    case 38:
+    case "Numpad5":
+      return ControlKey.Numpad5;
+    case 39:
+    case "Numpad6":
+      return ControlKey.Numpad6;
+    case 40:
+    case "Numpad7":
+      return ControlKey.Numpad7;
+    case 41:
+    case "Numpad8":
+      return ControlKey.Numpad8;
+    case 42:
+    case "Numpad9":
+      return ControlKey.Numpad9;
+    case 43:
+    case "Cancel":
+      return ControlKey.Cancel;
+    case 44:
+    case "Clear":
+      return ControlKey.Clear;
+    case 45:
+    case "Menu":
+      return ControlKey.Menu;
+    case 46:
+    case "Pause":
+      return ControlKey.Pause;
+    case 47:
+    case "Kana":
+      return ControlKey.Kana;
+    case 48:
+    case "Hangul":
+      return ControlKey.Hangul;
+    case 49:
+    case "Junja":
+      return ControlKey.Junja;
+    case 50:
+    case "Final":
+      return ControlKey.Final;
+    case 51:
+    case "Hanja":
+      return ControlKey.Hanja;
+    case 52:
+    case "Kanji":
+      return ControlKey.Kanji;
+    case 53:
+    case "Convert":
+      return ControlKey.Convert;
+    case 54:
+    case "Select":
+      return ControlKey.Select;
+    case 55:
+    case "Print":
+      return ControlKey.Print;
+    case 56:
+    case "Execute":
+      return ControlKey.Execute;
+    case 57:
+    case "Snapshot":
+      return ControlKey.Snapshot;
+    case 58:
+    case "Insert":
+      return ControlKey.Insert;
+    case 59:
+    case "Help":
+      return ControlKey.Help;
+    case 60:
+    case "Sleep":
+      return ControlKey.Sleep;
+    case 61:
+    case "Separator":
+      return ControlKey.Separator;
+    case 62:
+    case "Scroll":
+      return ControlKey.Scroll;
+    case 63:
+    case "NumLock":
+      return ControlKey.NumLock;
+    case 64:
+    case "RWin":
+      return ControlKey.RWin;
+    case 65:
+    case "Apps":
+      return ControlKey.Apps;
+    case 66:
+    case "Multiply":
+      return ControlKey.Multiply;
+    case 67:
+    case "Add":
+      return ControlKey.Add;
+    case 68:
+    case "Subtract":
+      return ControlKey.Subtract;
+    case 69:
+    case "Decimal":
+      return ControlKey.Decimal;
+    case 70:
+    case "Divide":
+      return ControlKey.Divide;
+    case 71:
+    case "Equals":
+      return ControlKey.Equals;
+    case 72:
+    case "NumpadEnter":
+      return ControlKey.NumpadEnter;
+    case 73:
+    case "RShift":
+      return ControlKey.RShift;
+    case 74:
+    case "RControl":
+      return ControlKey.RControl;
+    case 75:
+    case "RAlt":
+      return ControlKey.RAlt;
+    case 100:
+    case "CtrlAltDel":
+      return ControlKey.CtrlAltDel;
+    case 101:
+    case "LockScreen":
+      return ControlKey.LockScreen;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ControlKey.UNRECOGNIZED;
+  }
+}
+
+export function controlKeyToJSON(object: ControlKey): string {
+  switch (object) {
+    case ControlKey.Unknown:
+      return "Unknown";
+    case ControlKey.Alt:
+      return "Alt";
+    case ControlKey.Backspace:
+      return "Backspace";
+    case ControlKey.CapsLock:
+      return "CapsLock";
+    case ControlKey.Control:
+      return "Control";
+    case ControlKey.Delete:
+      return "Delete";
+    case ControlKey.DownArrow:
+      return "DownArrow";
+    case ControlKey.End:
+      return "End";
+    case ControlKey.Escape:
+      return "Escape";
+    case ControlKey.F1:
+      return "F1";
+    case ControlKey.F10:
+      return "F10";
+    case ControlKey.F11:
+      return "F11";
+    case ControlKey.F12:
+      return "F12";
+    case ControlKey.F2:
+      return "F2";
+    case ControlKey.F3:
+      return "F3";
+    case ControlKey.F4:
+      return "F4";
+    case ControlKey.F5:
+      return "F5";
+    case ControlKey.F6:
+      return "F6";
+    case ControlKey.F7:
+      return "F7";
+    case ControlKey.F8:
+      return "F8";
+    case ControlKey.F9:
+      return "F9";
+    case ControlKey.Home:
+      return "Home";
+    case ControlKey.LeftArrow:
+      return "LeftArrow";
+    case ControlKey.Meta:
+      return "Meta";
+    case ControlKey.Option:
+      return "Option";
+    case ControlKey.PageDown:
+      return "PageDown";
+    case ControlKey.PageUp:
+      return "PageUp";
+    case ControlKey.Return:
+      return "Return";
+    case ControlKey.RightArrow:
+      return "RightArrow";
+    case ControlKey.Shift:
+      return "Shift";
+    case ControlKey.Space:
+      return "Space";
+    case ControlKey.Tab:
+      return "Tab";
+    case ControlKey.UpArrow:
+      return "UpArrow";
+    case ControlKey.Numpad0:
+      return "Numpad0";
+    case ControlKey.Numpad1:
+      return "Numpad1";
+    case ControlKey.Numpad2:
+      return "Numpad2";
+    case ControlKey.Numpad3:
+      return "Numpad3";
+    case ControlKey.Numpad4:
+      return "Numpad4";
+    case ControlKey.Numpad5:
+      return "Numpad5";
+    case ControlKey.Numpad6:
+      return "Numpad6";
+    case ControlKey.Numpad7:
+      return "Numpad7";
+    case ControlKey.Numpad8:
+      return "Numpad8";
+    case ControlKey.Numpad9:
+      return "Numpad9";
+    case ControlKey.Cancel:
+      return "Cancel";
+    case ControlKey.Clear:
+      return "Clear";
+    case ControlKey.Menu:
+      return "Menu";
+    case ControlKey.Pause:
+      return "Pause";
+    case ControlKey.Kana:
+      return "Kana";
+    case ControlKey.Hangul:
+      return "Hangul";
+    case ControlKey.Junja:
+      return "Junja";
+    case ControlKey.Final:
+      return "Final";
+    case ControlKey.Hanja:
+      return "Hanja";
+    case ControlKey.Kanji:
+      return "Kanji";
+    case ControlKey.Convert:
+      return "Convert";
+    case ControlKey.Select:
+      return "Select";
+    case ControlKey.Print:
+      return "Print";
+    case ControlKey.Execute:
+      return "Execute";
+    case ControlKey.Snapshot:
+      return "Snapshot";
+    case ControlKey.Insert:
+      return "Insert";
+    case ControlKey.Help:
+      return "Help";
+    case ControlKey.Sleep:
+      return "Sleep";
+    case ControlKey.Separator:
+      return "Separator";
+    case ControlKey.Scroll:
+      return "Scroll";
+    case ControlKey.NumLock:
+      return "NumLock";
+    case ControlKey.RWin:
+      return "RWin";
+    case ControlKey.Apps:
+      return "Apps";
+    case ControlKey.Multiply:
+      return "Multiply";
+    case ControlKey.Add:
+      return "Add";
+    case ControlKey.Subtract:
+      return "Subtract";
+    case ControlKey.Decimal:
+      return "Decimal";
+    case ControlKey.Divide:
+      return "Divide";
+    case ControlKey.Equals:
+      return "Equals";
+    case ControlKey.NumpadEnter:
+      return "NumpadEnter";
+    case ControlKey.RShift:
+      return "RShift";
+    case ControlKey.RControl:
+      return "RControl";
+    case ControlKey.RAlt:
+      return "RAlt";
+    case ControlKey.CtrlAltDel:
+      return "CtrlAltDel";
+    case ControlKey.LockScreen:
+      return "LockScreen";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export enum FileType {
+  UnknownFileType = 0,
+  Dir = 1,
+  DirLink = 2,
+  DirDrive = 3,
+  File = 4,
+  FileLink = 5,
+  UNRECOGNIZED = -1,
+}
+
+export function fileTypeFromJSON(object: any): FileType {
+  switch (object) {
+    case 0:
+    case "UnknownFileType":
+      return FileType.UnknownFileType;
+    case 1:
+    case "Dir":
+      return FileType.Dir;
+    case 2:
+    case "DirLink":
+      return FileType.DirLink;
+    case 3:
+    case "DirDrive":
+      return FileType.DirDrive;
+    case 4:
+    case "File":
+      return FileType.File;
+    case 5:
+    case "FileLink":
+      return FileType.FileLink;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return FileType.UNRECOGNIZED;
+  }
+}
+
+export function fileTypeToJSON(object: FileType): string {
+  switch (object) {
+    case FileType.UnknownFileType:
+      return "UnknownFileType";
+    case FileType.Dir:
+      return "Dir";
+    case FileType.DirLink:
+      return "DirLink";
+    case FileType.DirDrive:
+      return "DirDrive";
+    case FileType.File:
+      return "File";
+    case FileType.FileLink:
+      return "FileLink";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export enum ImageQuality {
+  NotSet = 0,
+  Low = 2,
+  Balanced = 3,
+  Best = 4,
+  UNRECOGNIZED = -1,
+}
+
+export function imageQualityFromJSON(object: any): ImageQuality {
+  switch (object) {
+    case 0:
+    case "NotSet":
+      return ImageQuality.NotSet;
+    case 2:
+    case "Low":
+      return ImageQuality.Low;
+    case 3:
+    case "Balanced":
+      return ImageQuality.Balanced;
+    case 4:
+    case "Best":
+      return ImageQuality.Best;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ImageQuality.UNRECOGNIZED;
+  }
+}
+
+export function imageQualityToJSON(object: ImageQuality): string {
+  switch (object) {
+    case ImageQuality.NotSet:
+      return "NotSet";
+    case ImageQuality.Low:
+      return "Low";
+    case ImageQuality.Balanced:
+      return "Balanced";
+    case ImageQuality.Best:
+      return "Best";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export interface VP9 {
+  data: Uint8Array;
+  key: boolean;
+  pts: number;
+}
+
+export interface VP9s {
+  frames: VP9[];
+}
+
+export interface RGB {
+  compress: boolean;
+}
+
+/** planes data send directly in binary for better use arraybuffer on web */
+export interface YUV {
+  compress: boolean;
+  stride: number;
+}
+
+export interface VideoFrame {
+  vp9s: VP9s | undefined;
+  rgb: RGB | undefined;
+  yuv: YUV | undefined;
+}
+
+export interface DisplayInfo {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  name: string;
+  online: boolean;
+}
+
+export interface PortForward {
+  host: string;
+  port: number;
+}
+
+export interface FileTransfer {
+  dir: string;
+  showHidden: boolean;
+}
+
+export interface LoginRequest {
+  username: string;
+  password: Uint8Array;
+  myId: string;
+  myName: string;
+  option: OptionMessage | undefined;
+  fileTransfer: FileTransfer | undefined;
+  portForward: PortForward | undefined;
+}
+
+export interface ChatMessage {
+  text: string;
+}
+
+export interface PeerInfo {
+  username: string;
+  hostname: string;
+  platform: string;
+  displays: DisplayInfo[];
+  currentDisplay: number;
+  sasEnabled: boolean;
+  version: string;
+}
+
+export interface LoginResponse {
+  error: string | undefined;
+  peerInfo: PeerInfo | undefined;
+}
+
+export interface MouseEvent {
+  mask: number;
+  x: number;
+  y: number;
+  modifiers: ControlKey[];
+}
+
+export interface KeyEvent {
+  down: boolean;
+  press: boolean;
+  controlKey: ControlKey | undefined;
+  chr: number | undefined;
+  unicode: number | undefined;
+  seq: string | undefined;
+  modifiers: ControlKey[];
+}
+
+export interface CursorData {
+  id: number;
+  hotx: number;
+  hoty: number;
+  width: number;
+  height: number;
+  colors: Uint8Array;
+}
+
+export interface CursorPosition {
+  x: number;
+  y: number;
+}
+
+export interface Hash {
+  salt: string;
+  challenge: string;
+}
+
+export interface Clipboard {
+  compress: boolean;
+  content: Uint8Array;
+}
+
+export interface FileEntry {
+  entryType: FileType;
+  name: string;
+  isHidden: boolean;
+  size: number;
+  modifiedTime: number;
+}
+
+export interface FileDirectory {
+  id: number;
+  path: string;
+  entries: FileEntry[];
+}
+
+export interface ReadDir {
+  path: string;
+  includeHidden: boolean;
+}
+
+export interface ReadAllFiles {
+  id: number;
+  path: string;
+  includeHidden: boolean;
+}
+
+export interface FileAction {
+  readDir: ReadDir | undefined;
+  send: FileTransferSendRequest | undefined;
+  receive: FileTransferReceiveRequest | undefined;
+  create: FileDirCreate | undefined;
+  removeDir: FileRemoveDir | undefined;
+  removeFile: FileRemoveFile | undefined;
+  allFiles: ReadAllFiles | undefined;
+  cancel: FileTransferCancel | undefined;
+}
+
+export interface FileTransferCancel {
+  id: number;
+}
+
+export interface FileResponse {
+  dir: FileDirectory | undefined;
+  block: FileTransferBlock | undefined;
+  error: FileTransferError | undefined;
+  done: FileTransferDone | undefined;
+}
+
+export interface FileTransferBlock {
+  id: number;
+  fileNum: number;
+  data: Uint8Array;
+  compressed: boolean;
+}
+
+export interface FileTransferError {
+  id: number;
+  error: string;
+  fileNum: number;
+}
+
+export interface FileTransferSendRequest {
+  id: number;
+  path: string;
+  includeHidden: boolean;
+}
+
+export interface FileTransferDone {
+  id: number;
+  fileNum: number;
+}
+
+export interface FileTransferReceiveRequest {
+  id: number;
+  /** path written to */
+  path: string;
+  files: FileEntry[];
+}
+
+export interface FileRemoveDir {
+  id: number;
+  path: string;
+  recursive: boolean;
+}
+
+export interface FileRemoveFile {
+  id: number;
+  path: string;
+  fileNum: number;
+}
+
+export interface FileDirCreate {
+  id: number;
+  path: string;
+}
+
+export interface SwitchDisplay {
+  display: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface PermissionInfo {
+  permission: PermissionInfo_Permission;
+  enabled: boolean;
+}
+
+export enum PermissionInfo_Permission {
+  Unknown = 0,
+  Keyboard = 1,
+  Clipboard = 2,
+  Audio = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function permissionInfo_PermissionFromJSON(
+  object: any
+): PermissionInfo_Permission {
+  switch (object) {
+    case 0:
+    case "Unknown":
+      return PermissionInfo_Permission.Unknown;
+    case 1:
+    case "Keyboard":
+      return PermissionInfo_Permission.Keyboard;
+    case 2:
+    case "Clipboard":
+      return PermissionInfo_Permission.Clipboard;
+    case 3:
+    case "Audio":
+      return PermissionInfo_Permission.Audio;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return PermissionInfo_Permission.UNRECOGNIZED;
+  }
+}
+
+export function permissionInfo_PermissionToJSON(
+  object: PermissionInfo_Permission
+): string {
+  switch (object) {
+    case PermissionInfo_Permission.Unknown:
+      return "Unknown";
+    case PermissionInfo_Permission.Keyboard:
+      return "Keyboard";
+    case PermissionInfo_Permission.Clipboard:
+      return "Clipboard";
+    case PermissionInfo_Permission.Audio:
+      return "Audio";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export interface OptionMessage {
+  imageQuality: ImageQuality;
+  lockAfterSessionEnd: OptionMessage_BoolOption;
+  showRemoteCursor: OptionMessage_BoolOption;
+  privacyMode: OptionMessage_BoolOption;
+  blockInput: OptionMessage_BoolOption;
+  customImageQuality: number;
+  disableAudio: OptionMessage_BoolOption;
+  disableClipboard: OptionMessage_BoolOption;
+}
+
+export enum OptionMessage_BoolOption {
+  NotSet = 0,
+  No = 1,
+  Yes = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function optionMessage_BoolOptionFromJSON(
+  object: any
+): OptionMessage_BoolOption {
+  switch (object) {
+    case 0:
+    case "NotSet":
+      return OptionMessage_BoolOption.NotSet;
+    case 1:
+    case "No":
+      return OptionMessage_BoolOption.No;
+    case 2:
+    case "Yes":
+      return OptionMessage_BoolOption.Yes;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return OptionMessage_BoolOption.UNRECOGNIZED;
+  }
+}
+
+export function optionMessage_BoolOptionToJSON(
+  object: OptionMessage_BoolOption
+): string {
+  switch (object) {
+    case OptionMessage_BoolOption.NotSet:
+      return "NotSet";
+    case OptionMessage_BoolOption.No:
+      return "No";
+    case OptionMessage_BoolOption.Yes:
+      return "Yes";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export interface OptionResponse {
+  opt: OptionMessage | undefined;
+  error: string;
+}
+
+export interface TestDelay {
+  time: number;
+  fromClient: boolean;
+}
+
+export interface PublicKey {
+  asymmetricValue: Uint8Array;
+  symmetricValue: Uint8Array;
+}
+
+export interface SignedId {
+  id: Uint8Array;
+}
+
+export interface AudioFormat {
+  sampleRate: number;
+  channels: number;
+}
+
+export interface AudioFrame {
+  data: Uint8Array;
+}
+
+export interface Misc {
+  chatMessage: ChatMessage | undefined;
+  switchDisplay: SwitchDisplay | undefined;
+  permissionInfo: PermissionInfo | undefined;
+  option: OptionMessage | undefined;
+  audioFormat: AudioFormat | undefined;
+  closeReason: string | undefined;
+  refreshVideo: boolean | undefined;
+  optionResponse: OptionResponse | undefined;
+}
+
+export interface Message {
+  signedId: SignedId | undefined;
+  publicKey: PublicKey | undefined;
+  testDelay: TestDelay | undefined;
+  videoFrame: VideoFrame | undefined;
+  loginRequest: LoginRequest | undefined;
+  loginResponse: LoginResponse | undefined;
+  hash: Hash | undefined;
+  mouseEvent: MouseEvent | undefined;
+  audioFrame: AudioFrame | undefined;
+  cursorData: CursorData | undefined;
+  cursorPosition: CursorPosition | undefined;
+  cursorId: number | undefined;
+  keyEvent: KeyEvent | undefined;
+  clipboard: Clipboard | undefined;
+  fileAction: FileAction | undefined;
+  fileResponse: FileResponse | undefined;
+  misc: Misc | undefined;
+}
+
+function createBaseVP9(): VP9 {
+  return { data: new Uint8Array(), key: false, pts: 0 };
+}
+
+export const VP9 = {
+  encode(message: VP9, writer: Writer = Writer.create()): Writer {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    if (message.key === true) {
+      writer.uint32(16).bool(message.key);
+    }
+    if (message.pts !== 0) {
+      writer.uint32(24).int64(message.pts);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): VP9 {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVP9();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        case 2:
+          message.key = reader.bool();
+          break;
+        case 3:
+          message.pts = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): VP9 {
+    return {
+      data: isSet(object.data)
+        ? bytesFromBase64(object.data)
+        : new Uint8Array(),
+      key: isSet(object.key) ? Boolean(object.key) : false,
+      pts: isSet(object.pts) ? Number(object.pts) : 0,
+    };
+  },
+
+  toJSON(message: VP9): unknown {
+    const obj: any = {};
+    message.data !== undefined &&
+      (obj.data = base64FromBytes(
+        message.data !== undefined ? message.data : new Uint8Array()
+      ));
+    message.key !== undefined && (obj.key = message.key);
+    message.pts !== undefined && (obj.pts = Math.round(message.pts));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<VP9>, I>>(object: I): VP9 {
+    const message = createBaseVP9();
+    message.data = object.data ?? new Uint8Array();
+    message.key = object.key ?? false;
+    message.pts = object.pts ?? 0;
+    return message;
+  },
+};
+
+function createBaseVP9s(): VP9s {
+  return { frames: [] };
+}
+
+export const VP9s = {
+  encode(message: VP9s, writer: Writer = Writer.create()): Writer {
+    for (const v of message.frames) {
+      VP9.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): VP9s {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVP9s();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.frames.push(VP9.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): VP9s {
+    return {
+      frames: Array.isArray(object?.frames)
+        ? object.frames.map((e: any) => VP9.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: VP9s): unknown {
+    const obj: any = {};
+    if (message.frames) {
+      obj.frames = message.frames.map((e) => (e ? VP9.toJSON(e) : undefined));
+    } else {
+      obj.frames = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<VP9s>, I>>(object: I): VP9s {
+    const message = createBaseVP9s();
+    message.frames = object.frames?.map((e) => VP9.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseRGB(): RGB {
+  return { compress: false };
+}
+
+export const RGB = {
+  encode(message: RGB, writer: Writer = Writer.create()): Writer {
+    if (message.compress === true) {
+      writer.uint32(8).bool(message.compress);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RGB {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRGB();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.compress = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RGB {
+    return {
+      compress: isSet(object.compress) ? Boolean(object.compress) : false,
+    };
+  },
+
+  toJSON(message: RGB): unknown {
+    const obj: any = {};
+    message.compress !== undefined && (obj.compress = message.compress);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RGB>, I>>(object: I): RGB {
+    const message = createBaseRGB();
+    message.compress = object.compress ?? false;
+    return message;
+  },
+};
+
+function createBaseYUV(): YUV {
+  return { compress: false, stride: 0 };
+}
+
+export const YUV = {
+  encode(message: YUV, writer: Writer = Writer.create()): Writer {
+    if (message.compress === true) {
+      writer.uint32(8).bool(message.compress);
+    }
+    if (message.stride !== 0) {
+      writer.uint32(16).int32(message.stride);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): YUV {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseYUV();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.compress = reader.bool();
+          break;
+        case 2:
+          message.stride = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): YUV {
+    return {
+      compress: isSet(object.compress) ? Boolean(object.compress) : false,
+      stride: isSet(object.stride) ? Number(object.stride) : 0,
+    };
+  },
+
+  toJSON(message: YUV): unknown {
+    const obj: any = {};
+    message.compress !== undefined && (obj.compress = message.compress);
+    message.stride !== undefined && (obj.stride = Math.round(message.stride));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<YUV>, I>>(object: I): YUV {
+    const message = createBaseYUV();
+    message.compress = object.compress ?? false;
+    message.stride = object.stride ?? 0;
+    return message;
+  },
+};
+
+function createBaseVideoFrame(): VideoFrame {
+  return { vp9s: undefined, rgb: undefined, yuv: undefined };
+}
+
+export const VideoFrame = {
+  encode(message: VideoFrame, writer: Writer = Writer.create()): Writer {
+    if (message.vp9s !== undefined) {
+      VP9s.encode(message.vp9s, writer.uint32(50).fork()).ldelim();
+    }
+    if (message.rgb !== undefined) {
+      RGB.encode(message.rgb, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.yuv !== undefined) {
+      YUV.encode(message.yuv, writer.uint32(66).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): VideoFrame {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVideoFrame();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 6:
+          message.vp9s = VP9s.decode(reader, reader.uint32());
+          break;
+        case 7:
+          message.rgb = RGB.decode(reader, reader.uint32());
+          break;
+        case 8:
+          message.yuv = YUV.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): VideoFrame {
+    return {
+      vp9s: isSet(object.vp9s) ? VP9s.fromJSON(object.vp9s) : undefined,
+      rgb: isSet(object.rgb) ? RGB.fromJSON(object.rgb) : undefined,
+      yuv: isSet(object.yuv) ? YUV.fromJSON(object.yuv) : undefined,
+    };
+  },
+
+  toJSON(message: VideoFrame): unknown {
+    const obj: any = {};
+    message.vp9s !== undefined &&
+      (obj.vp9s = message.vp9s ? VP9s.toJSON(message.vp9s) : undefined);
+    message.rgb !== undefined &&
+      (obj.rgb = message.rgb ? RGB.toJSON(message.rgb) : undefined);
+    message.yuv !== undefined &&
+      (obj.yuv = message.yuv ? YUV.toJSON(message.yuv) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<VideoFrame>, I>>(
+    object: I
+  ): VideoFrame {
+    const message = createBaseVideoFrame();
+    message.vp9s =
+      object.vp9s !== undefined && object.vp9s !== null
+        ? VP9s.fromPartial(object.vp9s)
+        : undefined;
+    message.rgb =
+      object.rgb !== undefined && object.rgb !== null
+        ? RGB.fromPartial(object.rgb)
+        : undefined;
+    message.yuv =
+      object.yuv !== undefined && object.yuv !== null
+        ? YUV.fromPartial(object.yuv)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseDisplayInfo(): DisplayInfo {
+  return { x: 0, y: 0, width: 0, height: 0, name: "", online: false };
+}
+
+export const DisplayInfo = {
+  encode(message: DisplayInfo, writer: Writer = Writer.create()): Writer {
+    if (message.x !== 0) {
+      writer.uint32(8).sint32(message.x);
+    }
+    if (message.y !== 0) {
+      writer.uint32(16).sint32(message.y);
+    }
+    if (message.width !== 0) {
+      writer.uint32(24).int32(message.width);
+    }
+    if (message.height !== 0) {
+      writer.uint32(32).int32(message.height);
+    }
+    if (message.name !== "") {
+      writer.uint32(42).string(message.name);
+    }
+    if (message.online === true) {
+      writer.uint32(48).bool(message.online);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): DisplayInfo {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDisplayInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.x = reader.sint32();
+          break;
+        case 2:
+          message.y = reader.sint32();
+          break;
+        case 3:
+          message.width = reader.int32();
+          break;
+        case 4:
+          message.height = reader.int32();
+          break;
+        case 5:
+          message.name = reader.string();
+          break;
+        case 6:
+          message.online = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DisplayInfo {
+    return {
+      x: isSet(object.x) ? Number(object.x) : 0,
+      y: isSet(object.y) ? Number(object.y) : 0,
+      width: isSet(object.width) ? Number(object.width) : 0,
+      height: isSet(object.height) ? Number(object.height) : 0,
+      name: isSet(object.name) ? String(object.name) : "",
+      online: isSet(object.online) ? Boolean(object.online) : false,
+    };
+  },
+
+  toJSON(message: DisplayInfo): unknown {
+    const obj: any = {};
+    message.x !== undefined && (obj.x = Math.round(message.x));
+    message.y !== undefined && (obj.y = Math.round(message.y));
+    message.width !== undefined && (obj.width = Math.round(message.width));
+    message.height !== undefined && (obj.height = Math.round(message.height));
+    message.name !== undefined && (obj.name = message.name);
+    message.online !== undefined && (obj.online = message.online);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DisplayInfo>, I>>(
+    object: I
+  ): DisplayInfo {
+    const message = createBaseDisplayInfo();
+    message.x = object.x ?? 0;
+    message.y = object.y ?? 0;
+    message.width = object.width ?? 0;
+    message.height = object.height ?? 0;
+    message.name = object.name ?? "";
+    message.online = object.online ?? false;
+    return message;
+  },
+};
+
+function createBasePortForward(): PortForward {
+  return { host: "", port: 0 };
+}
+
+export const PortForward = {
+  encode(message: PortForward, writer: Writer = Writer.create()): Writer {
+    if (message.host !== "") {
+      writer.uint32(10).string(message.host);
+    }
+    if (message.port !== 0) {
+      writer.uint32(16).int32(message.port);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PortForward {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePortForward();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.host = reader.string();
+          break;
+        case 2:
+          message.port = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PortForward {
+    return {
+      host: isSet(object.host) ? String(object.host) : "",
+      port: isSet(object.port) ? Number(object.port) : 0,
+    };
+  },
+
+  toJSON(message: PortForward): unknown {
+    const obj: any = {};
+    message.host !== undefined && (obj.host = message.host);
+    message.port !== undefined && (obj.port = Math.round(message.port));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PortForward>, I>>(
+    object: I
+  ): PortForward {
+    const message = createBasePortForward();
+    message.host = object.host ?? "";
+    message.port = object.port ?? 0;
+    return message;
+  },
+};
+
+function createBaseFileTransfer(): FileTransfer {
+  return { dir: "", showHidden: false };
+}
+
+export const FileTransfer = {
+  encode(message: FileTransfer, writer: Writer = Writer.create()): Writer {
+    if (message.dir !== "") {
+      writer.uint32(10).string(message.dir);
+    }
+    if (message.showHidden === true) {
+      writer.uint32(16).bool(message.showHidden);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileTransfer {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTransfer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.dir = reader.string();
+          break;
+        case 2:
+          message.showHidden = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTransfer {
+    return {
+      dir: isSet(object.dir) ? String(object.dir) : "",
+      showHidden: isSet(object.showHidden) ? Boolean(object.showHidden) : false,
+    };
+  },
+
+  toJSON(message: FileTransfer): unknown {
+    const obj: any = {};
+    message.dir !== undefined && (obj.dir = message.dir);
+    message.showHidden !== undefined && (obj.showHidden = message.showHidden);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTransfer>, I>>(
+    object: I
+  ): FileTransfer {
+    const message = createBaseFileTransfer();
+    message.dir = object.dir ?? "";
+    message.showHidden = object.showHidden ?? false;
+    return message;
+  },
+};
+
+function createBaseLoginRequest(): LoginRequest {
+  return {
+    username: "",
+    password: new Uint8Array(),
+    myId: "",
+    myName: "",
+    option: undefined,
+    fileTransfer: undefined,
+    portForward: undefined,
+  };
+}
+
+export const LoginRequest = {
+  encode(message: LoginRequest, writer: Writer = Writer.create()): Writer {
+    if (message.username !== "") {
+      writer.uint32(10).string(message.username);
+    }
+    if (message.password.length !== 0) {
+      writer.uint32(18).bytes(message.password);
+    }
+    if (message.myId !== "") {
+      writer.uint32(34).string(message.myId);
+    }
+    if (message.myName !== "") {
+      writer.uint32(42).string(message.myName);
+    }
+    if (message.option !== undefined) {
+      OptionMessage.encode(message.option, writer.uint32(50).fork()).ldelim();
+    }
+    if (message.fileTransfer !== undefined) {
+      FileTransfer.encode(
+        message.fileTransfer,
+        writer.uint32(58).fork()
+      ).ldelim();
+    }
+    if (message.portForward !== undefined) {
+      PortForward.encode(
+        message.portForward,
+        writer.uint32(66).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): LoginRequest {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLoginRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.username = reader.string();
+          break;
+        case 2:
+          message.password = reader.bytes();
+          break;
+        case 4:
+          message.myId = reader.string();
+          break;
+        case 5:
+          message.myName = reader.string();
+          break;
+        case 6:
+          message.option = OptionMessage.decode(reader, reader.uint32());
+          break;
+        case 7:
+          message.fileTransfer = FileTransfer.decode(reader, reader.uint32());
+          break;
+        case 8:
+          message.portForward = PortForward.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): LoginRequest {
+    return {
+      username: isSet(object.username) ? String(object.username) : "",
+      password: isSet(object.password)
+        ? bytesFromBase64(object.password)
+        : new Uint8Array(),
+      myId: isSet(object.myId) ? String(object.myId) : "",
+      myName: isSet(object.myName) ? String(object.myName) : "",
+      option: isSet(object.option)
+        ? OptionMessage.fromJSON(object.option)
+        : undefined,
+      fileTransfer: isSet(object.fileTransfer)
+        ? FileTransfer.fromJSON(object.fileTransfer)
+        : undefined,
+      portForward: isSet(object.portForward)
+        ? PortForward.fromJSON(object.portForward)
+        : undefined,
+    };
+  },
+
+  toJSON(message: LoginRequest): unknown {
+    const obj: any = {};
+    message.username !== undefined && (obj.username = message.username);
+    message.password !== undefined &&
+      (obj.password = base64FromBytes(
+        message.password !== undefined ? message.password : new Uint8Array()
+      ));
+    message.myId !== undefined && (obj.myId = message.myId);
+    message.myName !== undefined && (obj.myName = message.myName);
+    message.option !== undefined &&
+      (obj.option = message.option
+        ? OptionMessage.toJSON(message.option)
+        : undefined);
+    message.fileTransfer !== undefined &&
+      (obj.fileTransfer = message.fileTransfer
+        ? FileTransfer.toJSON(message.fileTransfer)
+        : undefined);
+    message.portForward !== undefined &&
+      (obj.portForward = message.portForward
+        ? PortForward.toJSON(message.portForward)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<LoginRequest>, I>>(
+    object: I
+  ): LoginRequest {
+    const message = createBaseLoginRequest();
+    message.username = object.username ?? "";
+    message.password = object.password ?? new Uint8Array();
+    message.myId = object.myId ?? "";
+    message.myName = object.myName ?? "";
+    message.option =
+      object.option !== undefined && object.option !== null
+        ? OptionMessage.fromPartial(object.option)
+        : undefined;
+    message.fileTransfer =
+      object.fileTransfer !== undefined && object.fileTransfer !== null
+        ? FileTransfer.fromPartial(object.fileTransfer)
+        : undefined;
+    message.portForward =
+      object.portForward !== undefined && object.portForward !== null
+        ? PortForward.fromPartial(object.portForward)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseChatMessage(): ChatMessage {
+  return { text: "" };
+}
+
+export const ChatMessage = {
+  encode(message: ChatMessage, writer: Writer = Writer.create()): Writer {
+    if (message.text !== "") {
+      writer.uint32(10).string(message.text);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): ChatMessage {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChatMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.text = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ChatMessage {
+    return {
+      text: isSet(object.text) ? String(object.text) : "",
+    };
+  },
+
+  toJSON(message: ChatMessage): unknown {
+    const obj: any = {};
+    message.text !== undefined && (obj.text = message.text);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ChatMessage>, I>>(
+    object: I
+  ): ChatMessage {
+    const message = createBaseChatMessage();
+    message.text = object.text ?? "";
+    return message;
+  },
+};
+
+function createBasePeerInfo(): PeerInfo {
+  return {
+    username: "",
+    hostname: "",
+    platform: "",
+    displays: [],
+    currentDisplay: 0,
+    sasEnabled: false,
+    version: "",
+  };
+}
+
+export const PeerInfo = {
+  encode(message: PeerInfo, writer: Writer = Writer.create()): Writer {
+    if (message.username !== "") {
+      writer.uint32(10).string(message.username);
+    }
+    if (message.hostname !== "") {
+      writer.uint32(18).string(message.hostname);
+    }
+    if (message.platform !== "") {
+      writer.uint32(26).string(message.platform);
+    }
+    for (const v of message.displays) {
+      DisplayInfo.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.currentDisplay !== 0) {
+      writer.uint32(40).int32(message.currentDisplay);
+    }
+    if (message.sasEnabled === true) {
+      writer.uint32(48).bool(message.sasEnabled);
+    }
+    if (message.version !== "") {
+      writer.uint32(58).string(message.version);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PeerInfo {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePeerInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.username = reader.string();
+          break;
+        case 2:
+          message.hostname = reader.string();
+          break;
+        case 3:
+          message.platform = reader.string();
+          break;
+        case 4:
+          message.displays.push(DisplayInfo.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.currentDisplay = reader.int32();
+          break;
+        case 6:
+          message.sasEnabled = reader.bool();
+          break;
+        case 7:
+          message.version = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PeerInfo {
+    return {
+      username: isSet(object.username) ? String(object.username) : "",
+      hostname: isSet(object.hostname) ? String(object.hostname) : "",
+      platform: isSet(object.platform) ? String(object.platform) : "",
+      displays: Array.isArray(object?.displays)
+        ? object.displays.map((e: any) => DisplayInfo.fromJSON(e))
+        : [],
+      currentDisplay: isSet(object.currentDisplay)
+        ? Number(object.currentDisplay)
+        : 0,
+      sasEnabled: isSet(object.sasEnabled) ? Boolean(object.sasEnabled) : false,
+      version: isSet(object.version) ? String(object.version) : "",
+    };
+  },
+
+  toJSON(message: PeerInfo): unknown {
+    const obj: any = {};
+    message.username !== undefined && (obj.username = message.username);
+    message.hostname !== undefined && (obj.hostname = message.hostname);
+    message.platform !== undefined && (obj.platform = message.platform);
+    if (message.displays) {
+      obj.displays = message.displays.map((e) =>
+        e ? DisplayInfo.toJSON(e) : undefined
+      );
+    } else {
+      obj.displays = [];
+    }
+    message.currentDisplay !== undefined &&
+      (obj.currentDisplay = Math.round(message.currentDisplay));
+    message.sasEnabled !== undefined && (obj.sasEnabled = message.sasEnabled);
+    message.version !== undefined && (obj.version = message.version);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PeerInfo>, I>>(object: I): PeerInfo {
+    const message = createBasePeerInfo();
+    message.username = object.username ?? "";
+    message.hostname = object.hostname ?? "";
+    message.platform = object.platform ?? "";
+    message.displays =
+      object.displays?.map((e) => DisplayInfo.fromPartial(e)) || [];
+    message.currentDisplay = object.currentDisplay ?? 0;
+    message.sasEnabled = object.sasEnabled ?? false;
+    message.version = object.version ?? "";
+    return message;
+  },
+};
+
+function createBaseLoginResponse(): LoginResponse {
+  return { error: undefined, peerInfo: undefined };
+}
+
+export const LoginResponse = {
+  encode(message: LoginResponse, writer: Writer = Writer.create()): Writer {
+    if (message.error !== undefined) {
+      writer.uint32(10).string(message.error);
+    }
+    if (message.peerInfo !== undefined) {
+      PeerInfo.encode(message.peerInfo, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): LoginResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLoginResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.error = reader.string();
+          break;
+        case 2:
+          message.peerInfo = PeerInfo.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): LoginResponse {
+    return {
+      error: isSet(object.error) ? String(object.error) : undefined,
+      peerInfo: isSet(object.peerInfo)
+        ? PeerInfo.fromJSON(object.peerInfo)
+        : undefined,
+    };
+  },
+
+  toJSON(message: LoginResponse): unknown {
+    const obj: any = {};
+    message.error !== undefined && (obj.error = message.error);
+    message.peerInfo !== undefined &&
+      (obj.peerInfo = message.peerInfo
+        ? PeerInfo.toJSON(message.peerInfo)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<LoginResponse>, I>>(
+    object: I
+  ): LoginResponse {
+    const message = createBaseLoginResponse();
+    message.error = object.error ?? undefined;
+    message.peerInfo =
+      object.peerInfo !== undefined && object.peerInfo !== null
+        ? PeerInfo.fromPartial(object.peerInfo)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseMouseEvent(): MouseEvent {
+  return { mask: 0, x: 0, y: 0, modifiers: [] };
+}
+
+export const MouseEvent = {
+  encode(message: MouseEvent, writer: Writer = Writer.create()): Writer {
+    if (message.mask !== 0) {
+      writer.uint32(8).int32(message.mask);
+    }
+    if (message.x !== 0) {
+      writer.uint32(16).sint32(message.x);
+    }
+    if (message.y !== 0) {
+      writer.uint32(24).sint32(message.y);
+    }
+    writer.uint32(34).fork();
+    for (const v of message.modifiers) {
+      writer.int32(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MouseEvent {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMouseEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.mask = reader.int32();
+          break;
+        case 2:
+          message.x = reader.sint32();
+          break;
+        case 3:
+          message.y = reader.sint32();
+          break;
+        case 4:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.modifiers.push(reader.int32() as any);
+            }
+          } else {
+            message.modifiers.push(reader.int32() as any);
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MouseEvent {
+    return {
+      mask: isSet(object.mask) ? Number(object.mask) : 0,
+      x: isSet(object.x) ? Number(object.x) : 0,
+      y: isSet(object.y) ? Number(object.y) : 0,
+      modifiers: Array.isArray(object?.modifiers)
+        ? object.modifiers.map((e: any) => controlKeyFromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: MouseEvent): unknown {
+    const obj: any = {};
+    message.mask !== undefined && (obj.mask = Math.round(message.mask));
+    message.x !== undefined && (obj.x = Math.round(message.x));
+    message.y !== undefined && (obj.y = Math.round(message.y));
+    if (message.modifiers) {
+      obj.modifiers = message.modifiers.map((e) => controlKeyToJSON(e));
+    } else {
+      obj.modifiers = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MouseEvent>, I>>(
+    object: I
+  ): MouseEvent {
+    const message = createBaseMouseEvent();
+    message.mask = object.mask ?? 0;
+    message.x = object.x ?? 0;
+    message.y = object.y ?? 0;
+    message.modifiers = object.modifiers?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseKeyEvent(): KeyEvent {
+  return {
+    down: false,
+    press: false,
+    controlKey: undefined,
+    chr: undefined,
+    unicode: undefined,
+    seq: undefined,
+    modifiers: [],
+  };
+}
+
+export const KeyEvent = {
+  encode(message: KeyEvent, writer: Writer = Writer.create()): Writer {
+    if (message.down === true) {
+      writer.uint32(8).bool(message.down);
+    }
+    if (message.press === true) {
+      writer.uint32(16).bool(message.press);
+    }
+    if (message.controlKey !== undefined) {
+      writer.uint32(24).int32(message.controlKey);
+    }
+    if (message.chr !== undefined) {
+      writer.uint32(32).uint32(message.chr);
+    }
+    if (message.unicode !== undefined) {
+      writer.uint32(40).uint32(message.unicode);
+    }
+    if (message.seq !== undefined) {
+      writer.uint32(50).string(message.seq);
+    }
+    writer.uint32(66).fork();
+    for (const v of message.modifiers) {
+      writer.int32(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): KeyEvent {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseKeyEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.down = reader.bool();
+          break;
+        case 2:
+          message.press = reader.bool();
+          break;
+        case 3:
+          message.controlKey = reader.int32() as any;
+          break;
+        case 4:
+          message.chr = reader.uint32();
+          break;
+        case 5:
+          message.unicode = reader.uint32();
+          break;
+        case 6:
+          message.seq = reader.string();
+          break;
+        case 8:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.modifiers.push(reader.int32() as any);
+            }
+          } else {
+            message.modifiers.push(reader.int32() as any);
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): KeyEvent {
+    return {
+      down: isSet(object.down) ? Boolean(object.down) : false,
+      press: isSet(object.press) ? Boolean(object.press) : false,
+      controlKey: isSet(object.controlKey)
+        ? controlKeyFromJSON(object.controlKey)
+        : undefined,
+      chr: isSet(object.chr) ? Number(object.chr) : undefined,
+      unicode: isSet(object.unicode) ? Number(object.unicode) : undefined,
+      seq: isSet(object.seq) ? String(object.seq) : undefined,
+      modifiers: Array.isArray(object?.modifiers)
+        ? object.modifiers.map((e: any) => controlKeyFromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: KeyEvent): unknown {
+    const obj: any = {};
+    message.down !== undefined && (obj.down = message.down);
+    message.press !== undefined && (obj.press = message.press);
+    message.controlKey !== undefined &&
+      (obj.controlKey =
+        message.controlKey !== undefined
+          ? controlKeyToJSON(message.controlKey)
+          : undefined);
+    message.chr !== undefined && (obj.chr = Math.round(message.chr));
+    message.unicode !== undefined &&
+      (obj.unicode = Math.round(message.unicode));
+    message.seq !== undefined && (obj.seq = message.seq);
+    if (message.modifiers) {
+      obj.modifiers = message.modifiers.map((e) => controlKeyToJSON(e));
+    } else {
+      obj.modifiers = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<KeyEvent>, I>>(object: I): KeyEvent {
+    const message = createBaseKeyEvent();
+    message.down = object.down ?? false;
+    message.press = object.press ?? false;
+    message.controlKey = object.controlKey ?? undefined;
+    message.chr = object.chr ?? undefined;
+    message.unicode = object.unicode ?? undefined;
+    message.seq = object.seq ?? undefined;
+    message.modifiers = object.modifiers?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseCursorData(): CursorData {
+  return {
+    id: 0,
+    hotx: 0,
+    hoty: 0,
+    width: 0,
+    height: 0,
+    colors: new Uint8Array(),
+  };
+}
+
+export const CursorData = {
+  encode(message: CursorData, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint64(message.id);
+    }
+    if (message.hotx !== 0) {
+      writer.uint32(16).sint32(message.hotx);
+    }
+    if (message.hoty !== 0) {
+      writer.uint32(24).sint32(message.hoty);
+    }
+    if (message.width !== 0) {
+      writer.uint32(32).int32(message.width);
+    }
+    if (message.height !== 0) {
+      writer.uint32(40).int32(message.height);
+    }
+    if (message.colors.length !== 0) {
+      writer.uint32(50).bytes(message.colors);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): CursorData {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCursorData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = longToNumber(reader.uint64() as Long);
+          break;
+        case 2:
+          message.hotx = reader.sint32();
+          break;
+        case 3:
+          message.hoty = reader.sint32();
+          break;
+        case 4:
+          message.width = reader.int32();
+          break;
+        case 5:
+          message.height = reader.int32();
+          break;
+        case 6:
+          message.colors = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CursorData {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      hotx: isSet(object.hotx) ? Number(object.hotx) : 0,
+      hoty: isSet(object.hoty) ? Number(object.hoty) : 0,
+      width: isSet(object.width) ? Number(object.width) : 0,
+      height: isSet(object.height) ? Number(object.height) : 0,
+      colors: isSet(object.colors)
+        ? bytesFromBase64(object.colors)
+        : new Uint8Array(),
+    };
+  },
+
+  toJSON(message: CursorData): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.hotx !== undefined && (obj.hotx = Math.round(message.hotx));
+    message.hoty !== undefined && (obj.hoty = Math.round(message.hoty));
+    message.width !== undefined && (obj.width = Math.round(message.width));
+    message.height !== undefined && (obj.height = Math.round(message.height));
+    message.colors !== undefined &&
+      (obj.colors = base64FromBytes(
+        message.colors !== undefined ? message.colors : new Uint8Array()
+      ));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<CursorData>, I>>(
+    object: I
+  ): CursorData {
+    const message = createBaseCursorData();
+    message.id = object.id ?? 0;
+    message.hotx = object.hotx ?? 0;
+    message.hoty = object.hoty ?? 0;
+    message.width = object.width ?? 0;
+    message.height = object.height ?? 0;
+    message.colors = object.colors ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseCursorPosition(): CursorPosition {
+  return { x: 0, y: 0 };
+}
+
+export const CursorPosition = {
+  encode(message: CursorPosition, writer: Writer = Writer.create()): Writer {
+    if (message.x !== 0) {
+      writer.uint32(8).sint32(message.x);
+    }
+    if (message.y !== 0) {
+      writer.uint32(16).sint32(message.y);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): CursorPosition {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCursorPosition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.x = reader.sint32();
+          break;
+        case 2:
+          message.y = reader.sint32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CursorPosition {
+    return {
+      x: isSet(object.x) ? Number(object.x) : 0,
+      y: isSet(object.y) ? Number(object.y) : 0,
+    };
+  },
+
+  toJSON(message: CursorPosition): unknown {
+    const obj: any = {};
+    message.x !== undefined && (obj.x = Math.round(message.x));
+    message.y !== undefined && (obj.y = Math.round(message.y));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<CursorPosition>, I>>(
+    object: I
+  ): CursorPosition {
+    const message = createBaseCursorPosition();
+    message.x = object.x ?? 0;
+    message.y = object.y ?? 0;
+    return message;
+  },
+};
+
+function createBaseHash(): Hash {
+  return { salt: "", challenge: "" };
+}
+
+export const Hash = {
+  encode(message: Hash, writer: Writer = Writer.create()): Writer {
+    if (message.salt !== "") {
+      writer.uint32(10).string(message.salt);
+    }
+    if (message.challenge !== "") {
+      writer.uint32(18).string(message.challenge);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): Hash {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHash();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.salt = reader.string();
+          break;
+        case 2:
+          message.challenge = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Hash {
+    return {
+      salt: isSet(object.salt) ? String(object.salt) : "",
+      challenge: isSet(object.challenge) ? String(object.challenge) : "",
+    };
+  },
+
+  toJSON(message: Hash): unknown {
+    const obj: any = {};
+    message.salt !== undefined && (obj.salt = message.salt);
+    message.challenge !== undefined && (obj.challenge = message.challenge);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Hash>, I>>(object: I): Hash {
+    const message = createBaseHash();
+    message.salt = object.salt ?? "";
+    message.challenge = object.challenge ?? "";
+    return message;
+  },
+};
+
+function createBaseClipboard(): Clipboard {
+  return { compress: false, content: new Uint8Array() };
+}
+
+export const Clipboard = {
+  encode(message: Clipboard, writer: Writer = Writer.create()): Writer {
+    if (message.compress === true) {
+      writer.uint32(8).bool(message.compress);
+    }
+    if (message.content.length !== 0) {
+      writer.uint32(18).bytes(message.content);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): Clipboard {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClipboard();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.compress = reader.bool();
+          break;
+        case 2:
+          message.content = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Clipboard {
+    return {
+      compress: isSet(object.compress) ? Boolean(object.compress) : false,
+      content: isSet(object.content)
+        ? bytesFromBase64(object.content)
+        : new Uint8Array(),
+    };
+  },
+
+  toJSON(message: Clipboard): unknown {
+    const obj: any = {};
+    message.compress !== undefined && (obj.compress = message.compress);
+    message.content !== undefined &&
+      (obj.content = base64FromBytes(
+        message.content !== undefined ? message.content : new Uint8Array()
+      ));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Clipboard>, I>>(
+    object: I
+  ): Clipboard {
+    const message = createBaseClipboard();
+    message.compress = object.compress ?? false;
+    message.content = object.content ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseFileEntry(): FileEntry {
+  return { entryType: 0, name: "", isHidden: false, size: 0, modifiedTime: 0 };
+}
+
+export const FileEntry = {
+  encode(message: FileEntry, writer: Writer = Writer.create()): Writer {
+    if (message.entryType !== 0) {
+      writer.uint32(8).int32(message.entryType);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.isHidden === true) {
+      writer.uint32(24).bool(message.isHidden);
+    }
+    if (message.size !== 0) {
+      writer.uint32(32).uint64(message.size);
+    }
+    if (message.modifiedTime !== 0) {
+      writer.uint32(40).uint64(message.modifiedTime);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileEntry {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.entryType = reader.int32() as any;
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        case 3:
+          message.isHidden = reader.bool();
+          break;
+        case 4:
+          message.size = longToNumber(reader.uint64() as Long);
+          break;
+        case 5:
+          message.modifiedTime = longToNumber(reader.uint64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileEntry {
+    return {
+      entryType: isSet(object.entryType)
+        ? fileTypeFromJSON(object.entryType)
+        : 0,
+      name: isSet(object.name) ? String(object.name) : "",
+      isHidden: isSet(object.isHidden) ? Boolean(object.isHidden) : false,
+      size: isSet(object.size) ? Number(object.size) : 0,
+      modifiedTime: isSet(object.modifiedTime)
+        ? Number(object.modifiedTime)
+        : 0,
+    };
+  },
+
+  toJSON(message: FileEntry): unknown {
+    const obj: any = {};
+    message.entryType !== undefined &&
+      (obj.entryType = fileTypeToJSON(message.entryType));
+    message.name !== undefined && (obj.name = message.name);
+    message.isHidden !== undefined && (obj.isHidden = message.isHidden);
+    message.size !== undefined && (obj.size = Math.round(message.size));
+    message.modifiedTime !== undefined &&
+      (obj.modifiedTime = Math.round(message.modifiedTime));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileEntry>, I>>(
+    object: I
+  ): FileEntry {
+    const message = createBaseFileEntry();
+    message.entryType = object.entryType ?? 0;
+    message.name = object.name ?? "";
+    message.isHidden = object.isHidden ?? false;
+    message.size = object.size ?? 0;
+    message.modifiedTime = object.modifiedTime ?? 0;
+    return message;
+  },
+};
+
+function createBaseFileDirectory(): FileDirectory {
+  return { id: 0, path: "", entries: [] };
+}
+
+export const FileDirectory = {
+  encode(message: FileDirectory, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    for (const v of message.entries) {
+      FileEntry.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileDirectory {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileDirectory();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.path = reader.string();
+          break;
+        case 3:
+          message.entries.push(FileEntry.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileDirectory {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      path: isSet(object.path) ? String(object.path) : "",
+      entries: Array.isArray(object?.entries)
+        ? object.entries.map((e: any) => FileEntry.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: FileDirectory): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.path !== undefined && (obj.path = message.path);
+    if (message.entries) {
+      obj.entries = message.entries.map((e) =>
+        e ? FileEntry.toJSON(e) : undefined
+      );
+    } else {
+      obj.entries = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileDirectory>, I>>(
+    object: I
+  ): FileDirectory {
+    const message = createBaseFileDirectory();
+    message.id = object.id ?? 0;
+    message.path = object.path ?? "";
+    message.entries =
+      object.entries?.map((e) => FileEntry.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseReadDir(): ReadDir {
+  return { path: "", includeHidden: false };
+}
+
+export const ReadDir = {
+  encode(message: ReadDir, writer: Writer = Writer.create()): Writer {
+    if (message.path !== "") {
+      writer.uint32(10).string(message.path);
+    }
+    if (message.includeHidden === true) {
+      writer.uint32(16).bool(message.includeHidden);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): ReadDir {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadDir();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.path = reader.string();
+          break;
+        case 2:
+          message.includeHidden = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ReadDir {
+    return {
+      path: isSet(object.path) ? String(object.path) : "",
+      includeHidden: isSet(object.includeHidden)
+        ? Boolean(object.includeHidden)
+        : false,
+    };
+  },
+
+  toJSON(message: ReadDir): unknown {
+    const obj: any = {};
+    message.path !== undefined && (obj.path = message.path);
+    message.includeHidden !== undefined &&
+      (obj.includeHidden = message.includeHidden);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ReadDir>, I>>(object: I): ReadDir {
+    const message = createBaseReadDir();
+    message.path = object.path ?? "";
+    message.includeHidden = object.includeHidden ?? false;
+    return message;
+  },
+};
+
+function createBaseReadAllFiles(): ReadAllFiles {
+  return { id: 0, path: "", includeHidden: false };
+}
+
+export const ReadAllFiles = {
+  encode(message: ReadAllFiles, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    if (message.includeHidden === true) {
+      writer.uint32(24).bool(message.includeHidden);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): ReadAllFiles {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadAllFiles();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.path = reader.string();
+          break;
+        case 3:
+          message.includeHidden = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ReadAllFiles {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      path: isSet(object.path) ? String(object.path) : "",
+      includeHidden: isSet(object.includeHidden)
+        ? Boolean(object.includeHidden)
+        : false,
+    };
+  },
+
+  toJSON(message: ReadAllFiles): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.path !== undefined && (obj.path = message.path);
+    message.includeHidden !== undefined &&
+      (obj.includeHidden = message.includeHidden);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ReadAllFiles>, I>>(
+    object: I
+  ): ReadAllFiles {
+    const message = createBaseReadAllFiles();
+    message.id = object.id ?? 0;
+    message.path = object.path ?? "";
+    message.includeHidden = object.includeHidden ?? false;
+    return message;
+  },
+};
+
+function createBaseFileAction(): FileAction {
+  return {
+    readDir: undefined,
+    send: undefined,
+    receive: undefined,
+    create: undefined,
+    removeDir: undefined,
+    removeFile: undefined,
+    allFiles: undefined,
+    cancel: undefined,
+  };
+}
+
+export const FileAction = {
+  encode(message: FileAction, writer: Writer = Writer.create()): Writer {
+    if (message.readDir !== undefined) {
+      ReadDir.encode(message.readDir, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.send !== undefined) {
+      FileTransferSendRequest.encode(
+        message.send,
+        writer.uint32(18).fork()
+      ).ldelim();
+    }
+    if (message.receive !== undefined) {
+      FileTransferReceiveRequest.encode(
+        message.receive,
+        writer.uint32(26).fork()
+      ).ldelim();
+    }
+    if (message.create !== undefined) {
+      FileDirCreate.encode(message.create, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.removeDir !== undefined) {
+      FileRemoveDir.encode(
+        message.removeDir,
+        writer.uint32(42).fork()
+      ).ldelim();
+    }
+    if (message.removeFile !== undefined) {
+      FileRemoveFile.encode(
+        message.removeFile,
+        writer.uint32(50).fork()
+      ).ldelim();
+    }
+    if (message.allFiles !== undefined) {
+      ReadAllFiles.encode(message.allFiles, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.cancel !== undefined) {
+      FileTransferCancel.encode(
+        message.cancel,
+        writer.uint32(66).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileAction {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileAction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.readDir = ReadDir.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.send = FileTransferSendRequest.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 3:
+          message.receive = FileTransferReceiveRequest.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 4:
+          message.create = FileDirCreate.decode(reader, reader.uint32());
+          break;
+        case 5:
+          message.removeDir = FileRemoveDir.decode(reader, reader.uint32());
+          break;
+        case 6:
+          message.removeFile = FileRemoveFile.decode(reader, reader.uint32());
+          break;
+        case 7:
+          message.allFiles = ReadAllFiles.decode(reader, reader.uint32());
+          break;
+        case 8:
+          message.cancel = FileTransferCancel.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileAction {
+    return {
+      readDir: isSet(object.readDir)
+        ? ReadDir.fromJSON(object.readDir)
+        : undefined,
+      send: isSet(object.send)
+        ? FileTransferSendRequest.fromJSON(object.send)
+        : undefined,
+      receive: isSet(object.receive)
+        ? FileTransferReceiveRequest.fromJSON(object.receive)
+        : undefined,
+      create: isSet(object.create)
+        ? FileDirCreate.fromJSON(object.create)
+        : undefined,
+      removeDir: isSet(object.removeDir)
+        ? FileRemoveDir.fromJSON(object.removeDir)
+        : undefined,
+      removeFile: isSet(object.removeFile)
+        ? FileRemoveFile.fromJSON(object.removeFile)
+        : undefined,
+      allFiles: isSet(object.allFiles)
+        ? ReadAllFiles.fromJSON(object.allFiles)
+        : undefined,
+      cancel: isSet(object.cancel)
+        ? FileTransferCancel.fromJSON(object.cancel)
+        : undefined,
+    };
+  },
+
+  toJSON(message: FileAction): unknown {
+    const obj: any = {};
+    message.readDir !== undefined &&
+      (obj.readDir = message.readDir
+        ? ReadDir.toJSON(message.readDir)
+        : undefined);
+    message.send !== undefined &&
+      (obj.send = message.send
+        ? FileTransferSendRequest.toJSON(message.send)
+        : undefined);
+    message.receive !== undefined &&
+      (obj.receive = message.receive
+        ? FileTransferReceiveRequest.toJSON(message.receive)
+        : undefined);
+    message.create !== undefined &&
+      (obj.create = message.create
+        ? FileDirCreate.toJSON(message.create)
+        : undefined);
+    message.removeDir !== undefined &&
+      (obj.removeDir = message.removeDir
+        ? FileRemoveDir.toJSON(message.removeDir)
+        : undefined);
+    message.removeFile !== undefined &&
+      (obj.removeFile = message.removeFile
+        ? FileRemoveFile.toJSON(message.removeFile)
+        : undefined);
+    message.allFiles !== undefined &&
+      (obj.allFiles = message.allFiles
+        ? ReadAllFiles.toJSON(message.allFiles)
+        : undefined);
+    message.cancel !== undefined &&
+      (obj.cancel = message.cancel
+        ? FileTransferCancel.toJSON(message.cancel)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileAction>, I>>(
+    object: I
+  ): FileAction {
+    const message = createBaseFileAction();
+    message.readDir =
+      object.readDir !== undefined && object.readDir !== null
+        ? ReadDir.fromPartial(object.readDir)
+        : undefined;
+    message.send =
+      object.send !== undefined && object.send !== null
+        ? FileTransferSendRequest.fromPartial(object.send)
+        : undefined;
+    message.receive =
+      object.receive !== undefined && object.receive !== null
+        ? FileTransferReceiveRequest.fromPartial(object.receive)
+        : undefined;
+    message.create =
+      object.create !== undefined && object.create !== null
+        ? FileDirCreate.fromPartial(object.create)
+        : undefined;
+    message.removeDir =
+      object.removeDir !== undefined && object.removeDir !== null
+        ? FileRemoveDir.fromPartial(object.removeDir)
+        : undefined;
+    message.removeFile =
+      object.removeFile !== undefined && object.removeFile !== null
+        ? FileRemoveFile.fromPartial(object.removeFile)
+        : undefined;
+    message.allFiles =
+      object.allFiles !== undefined && object.allFiles !== null
+        ? ReadAllFiles.fromPartial(object.allFiles)
+        : undefined;
+    message.cancel =
+      object.cancel !== undefined && object.cancel !== null
+        ? FileTransferCancel.fromPartial(object.cancel)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseFileTransferCancel(): FileTransferCancel {
+  return { id: 0 };
+}
+
+export const FileTransferCancel = {
+  encode(
+    message: FileTransferCancel,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileTransferCancel {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTransferCancel();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTransferCancel {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+    };
+  },
+
+  toJSON(message: FileTransferCancel): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTransferCancel>, I>>(
+    object: I
+  ): FileTransferCancel {
+    const message = createBaseFileTransferCancel();
+    message.id = object.id ?? 0;
+    return message;
+  },
+};
+
+function createBaseFileResponse(): FileResponse {
+  return {
+    dir: undefined,
+    block: undefined,
+    error: undefined,
+    done: undefined,
+  };
+}
+
+export const FileResponse = {
+  encode(message: FileResponse, writer: Writer = Writer.create()): Writer {
+    if (message.dir !== undefined) {
+      FileDirectory.encode(message.dir, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.block !== undefined) {
+      FileTransferBlock.encode(
+        message.block,
+        writer.uint32(18).fork()
+      ).ldelim();
+    }
+    if (message.error !== undefined) {
+      FileTransferError.encode(
+        message.error,
+        writer.uint32(26).fork()
+      ).ldelim();
+    }
+    if (message.done !== undefined) {
+      FileTransferDone.encode(message.done, writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.dir = FileDirectory.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.block = FileTransferBlock.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.error = FileTransferError.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.done = FileTransferDone.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileResponse {
+    return {
+      dir: isSet(object.dir) ? FileDirectory.fromJSON(object.dir) : undefined,
+      block: isSet(object.block)
+        ? FileTransferBlock.fromJSON(object.block)
+        : undefined,
+      error: isSet(object.error)
+        ? FileTransferError.fromJSON(object.error)
+        : undefined,
+      done: isSet(object.done)
+        ? FileTransferDone.fromJSON(object.done)
+        : undefined,
+    };
+  },
+
+  toJSON(message: FileResponse): unknown {
+    const obj: any = {};
+    message.dir !== undefined &&
+      (obj.dir = message.dir ? FileDirectory.toJSON(message.dir) : undefined);
+    message.block !== undefined &&
+      (obj.block = message.block
+        ? FileTransferBlock.toJSON(message.block)
+        : undefined);
+    message.error !== undefined &&
+      (obj.error = message.error
+        ? FileTransferError.toJSON(message.error)
+        : undefined);
+    message.done !== undefined &&
+      (obj.done = message.done
+        ? FileTransferDone.toJSON(message.done)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileResponse>, I>>(
+    object: I
+  ): FileResponse {
+    const message = createBaseFileResponse();
+    message.dir =
+      object.dir !== undefined && object.dir !== null
+        ? FileDirectory.fromPartial(object.dir)
+        : undefined;
+    message.block =
+      object.block !== undefined && object.block !== null
+        ? FileTransferBlock.fromPartial(object.block)
+        : undefined;
+    message.error =
+      object.error !== undefined && object.error !== null
+        ? FileTransferError.fromPartial(object.error)
+        : undefined;
+    message.done =
+      object.done !== undefined && object.done !== null
+        ? FileTransferDone.fromPartial(object.done)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseFileTransferBlock(): FileTransferBlock {
+  return { id: 0, fileNum: 0, data: new Uint8Array(), compressed: false };
+}
+
+export const FileTransferBlock = {
+  encode(message: FileTransferBlock, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.fileNum !== 0) {
+      writer.uint32(16).sint32(message.fileNum);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(26).bytes(message.data);
+    }
+    if (message.compressed === true) {
+      writer.uint32(32).bool(message.compressed);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileTransferBlock {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTransferBlock();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.fileNum = reader.sint32();
+          break;
+        case 3:
+          message.data = reader.bytes();
+          break;
+        case 4:
+          message.compressed = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTransferBlock {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      fileNum: isSet(object.fileNum) ? Number(object.fileNum) : 0,
+      data: isSet(object.data)
+        ? bytesFromBase64(object.data)
+        : new Uint8Array(),
+      compressed: isSet(object.compressed) ? Boolean(object.compressed) : false,
+    };
+  },
+
+  toJSON(message: FileTransferBlock): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.fileNum !== undefined &&
+      (obj.fileNum = Math.round(message.fileNum));
+    message.data !== undefined &&
+      (obj.data = base64FromBytes(
+        message.data !== undefined ? message.data : new Uint8Array()
+      ));
+    message.compressed !== undefined && (obj.compressed = message.compressed);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTransferBlock>, I>>(
+    object: I
+  ): FileTransferBlock {
+    const message = createBaseFileTransferBlock();
+    message.id = object.id ?? 0;
+    message.fileNum = object.fileNum ?? 0;
+    message.data = object.data ?? new Uint8Array();
+    message.compressed = object.compressed ?? false;
+    return message;
+  },
+};
+
+function createBaseFileTransferError(): FileTransferError {
+  return { id: 0, error: "", fileNum: 0 };
+}
+
+export const FileTransferError = {
+  encode(message: FileTransferError, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.error !== "") {
+      writer.uint32(18).string(message.error);
+    }
+    if (message.fileNum !== 0) {
+      writer.uint32(24).sint32(message.fileNum);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileTransferError {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTransferError();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.error = reader.string();
+          break;
+        case 3:
+          message.fileNum = reader.sint32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTransferError {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      error: isSet(object.error) ? String(object.error) : "",
+      fileNum: isSet(object.fileNum) ? Number(object.fileNum) : 0,
+    };
+  },
+
+  toJSON(message: FileTransferError): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.error !== undefined && (obj.error = message.error);
+    message.fileNum !== undefined &&
+      (obj.fileNum = Math.round(message.fileNum));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTransferError>, I>>(
+    object: I
+  ): FileTransferError {
+    const message = createBaseFileTransferError();
+    message.id = object.id ?? 0;
+    message.error = object.error ?? "";
+    message.fileNum = object.fileNum ?? 0;
+    return message;
+  },
+};
+
+function createBaseFileTransferSendRequest(): FileTransferSendRequest {
+  return { id: 0, path: "", includeHidden: false };
+}
+
+export const FileTransferSendRequest = {
+  encode(
+    message: FileTransferSendRequest,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    if (message.includeHidden === true) {
+      writer.uint32(24).bool(message.includeHidden);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileTransferSendRequest {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTransferSendRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.path = reader.string();
+          break;
+        case 3:
+          message.includeHidden = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTransferSendRequest {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      path: isSet(object.path) ? String(object.path) : "",
+      includeHidden: isSet(object.includeHidden)
+        ? Boolean(object.includeHidden)
+        : false,
+    };
+  },
+
+  toJSON(message: FileTransferSendRequest): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.path !== undefined && (obj.path = message.path);
+    message.includeHidden !== undefined &&
+      (obj.includeHidden = message.includeHidden);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTransferSendRequest>, I>>(
+    object: I
+  ): FileTransferSendRequest {
+    const message = createBaseFileTransferSendRequest();
+    message.id = object.id ?? 0;
+    message.path = object.path ?? "";
+    message.includeHidden = object.includeHidden ?? false;
+    return message;
+  },
+};
+
+function createBaseFileTransferDone(): FileTransferDone {
+  return { id: 0, fileNum: 0 };
+}
+
+export const FileTransferDone = {
+  encode(message: FileTransferDone, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.fileNum !== 0) {
+      writer.uint32(16).sint32(message.fileNum);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileTransferDone {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTransferDone();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.fileNum = reader.sint32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTransferDone {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      fileNum: isSet(object.fileNum) ? Number(object.fileNum) : 0,
+    };
+  },
+
+  toJSON(message: FileTransferDone): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.fileNum !== undefined &&
+      (obj.fileNum = Math.round(message.fileNum));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTransferDone>, I>>(
+    object: I
+  ): FileTransferDone {
+    const message = createBaseFileTransferDone();
+    message.id = object.id ?? 0;
+    message.fileNum = object.fileNum ?? 0;
+    return message;
+  },
+};
+
+function createBaseFileTransferReceiveRequest(): FileTransferReceiveRequest {
+  return { id: 0, path: "", files: [] };
+}
+
+export const FileTransferReceiveRequest = {
+  encode(
+    message: FileTransferReceiveRequest,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    for (const v of message.files) {
+      FileEntry.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(
+    input: Reader | Uint8Array,
+    length?: number
+  ): FileTransferReceiveRequest {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTransferReceiveRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.path = reader.string();
+          break;
+        case 3:
+          message.files.push(FileEntry.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTransferReceiveRequest {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      path: isSet(object.path) ? String(object.path) : "",
+      files: Array.isArray(object?.files)
+        ? object.files.map((e: any) => FileEntry.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: FileTransferReceiveRequest): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.path !== undefined && (obj.path = message.path);
+    if (message.files) {
+      obj.files = message.files.map((e) =>
+        e ? FileEntry.toJSON(e) : undefined
+      );
+    } else {
+      obj.files = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTransferReceiveRequest>, I>>(
+    object: I
+  ): FileTransferReceiveRequest {
+    const message = createBaseFileTransferReceiveRequest();
+    message.id = object.id ?? 0;
+    message.path = object.path ?? "";
+    message.files = object.files?.map((e) => FileEntry.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseFileRemoveDir(): FileRemoveDir {
+  return { id: 0, path: "", recursive: false };
+}
+
+export const FileRemoveDir = {
+  encode(message: FileRemoveDir, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    if (message.recursive === true) {
+      writer.uint32(24).bool(message.recursive);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileRemoveDir {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileRemoveDir();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.path = reader.string();
+          break;
+        case 3:
+          message.recursive = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileRemoveDir {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      path: isSet(object.path) ? String(object.path) : "",
+      recursive: isSet(object.recursive) ? Boolean(object.recursive) : false,
+    };
+  },
+
+  toJSON(message: FileRemoveDir): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.path !== undefined && (obj.path = message.path);
+    message.recursive !== undefined && (obj.recursive = message.recursive);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileRemoveDir>, I>>(
+    object: I
+  ): FileRemoveDir {
+    const message = createBaseFileRemoveDir();
+    message.id = object.id ?? 0;
+    message.path = object.path ?? "";
+    message.recursive = object.recursive ?? false;
+    return message;
+  },
+};
+
+function createBaseFileRemoveFile(): FileRemoveFile {
+  return { id: 0, path: "", fileNum: 0 };
+}
+
+export const FileRemoveFile = {
+  encode(message: FileRemoveFile, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    if (message.fileNum !== 0) {
+      writer.uint32(24).sint32(message.fileNum);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileRemoveFile {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileRemoveFile();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.path = reader.string();
+          break;
+        case 3:
+          message.fileNum = reader.sint32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileRemoveFile {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      path: isSet(object.path) ? String(object.path) : "",
+      fileNum: isSet(object.fileNum) ? Number(object.fileNum) : 0,
+    };
+  },
+
+  toJSON(message: FileRemoveFile): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.path !== undefined && (obj.path = message.path);
+    message.fileNum !== undefined &&
+      (obj.fileNum = Math.round(message.fileNum));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileRemoveFile>, I>>(
+    object: I
+  ): FileRemoveFile {
+    const message = createBaseFileRemoveFile();
+    message.id = object.id ?? 0;
+    message.path = object.path ?? "";
+    message.fileNum = object.fileNum ?? 0;
+    return message;
+  },
+};
+
+function createBaseFileDirCreate(): FileDirCreate {
+  return { id: 0, path: "" };
+}
+
+export const FileDirCreate = {
+  encode(message: FileDirCreate, writer: Writer = Writer.create()): Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.path !== "") {
+      writer.uint32(18).string(message.path);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FileDirCreate {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileDirCreate();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.int32();
+          break;
+        case 2:
+          message.path = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileDirCreate {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      path: isSet(object.path) ? String(object.path) : "",
+    };
+  },
+
+  toJSON(message: FileDirCreate): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.path !== undefined && (obj.path = message.path);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileDirCreate>, I>>(
+    object: I
+  ): FileDirCreate {
+    const message = createBaseFileDirCreate();
+    message.id = object.id ?? 0;
+    message.path = object.path ?? "";
+    return message;
+  },
+};
+
+function createBaseSwitchDisplay(): SwitchDisplay {
+  return { display: 0, x: 0, y: 0, width: 0, height: 0 };
+}
+
+export const SwitchDisplay = {
+  encode(message: SwitchDisplay, writer: Writer = Writer.create()): Writer {
+    if (message.display !== 0) {
+      writer.uint32(8).int32(message.display);
+    }
+    if (message.x !== 0) {
+      writer.uint32(16).sint32(message.x);
+    }
+    if (message.y !== 0) {
+      writer.uint32(24).sint32(message.y);
+    }
+    if (message.width !== 0) {
+      writer.uint32(32).int32(message.width);
+    }
+    if (message.height !== 0) {
+      writer.uint32(40).int32(message.height);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): SwitchDisplay {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSwitchDisplay();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.display = reader.int32();
+          break;
+        case 2:
+          message.x = reader.sint32();
+          break;
+        case 3:
+          message.y = reader.sint32();
+          break;
+        case 4:
+          message.width = reader.int32();
+          break;
+        case 5:
+          message.height = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SwitchDisplay {
+    return {
+      display: isSet(object.display) ? Number(object.display) : 0,
+      x: isSet(object.x) ? Number(object.x) : 0,
+      y: isSet(object.y) ? Number(object.y) : 0,
+      width: isSet(object.width) ? Number(object.width) : 0,
+      height: isSet(object.height) ? Number(object.height) : 0,
+    };
+  },
+
+  toJSON(message: SwitchDisplay): unknown {
+    const obj: any = {};
+    message.display !== undefined &&
+      (obj.display = Math.round(message.display));
+    message.x !== undefined && (obj.x = Math.round(message.x));
+    message.y !== undefined && (obj.y = Math.round(message.y));
+    message.width !== undefined && (obj.width = Math.round(message.width));
+    message.height !== undefined && (obj.height = Math.round(message.height));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SwitchDisplay>, I>>(
+    object: I
+  ): SwitchDisplay {
+    const message = createBaseSwitchDisplay();
+    message.display = object.display ?? 0;
+    message.x = object.x ?? 0;
+    message.y = object.y ?? 0;
+    message.width = object.width ?? 0;
+    message.height = object.height ?? 0;
+    return message;
+  },
+};
+
+function createBasePermissionInfo(): PermissionInfo {
+  return { permission: 0, enabled: false };
+}
+
+export const PermissionInfo = {
+  encode(message: PermissionInfo, writer: Writer = Writer.create()): Writer {
+    if (message.permission !== 0) {
+      writer.uint32(8).int32(message.permission);
+    }
+    if (message.enabled === true) {
+      writer.uint32(16).bool(message.enabled);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PermissionInfo {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePermissionInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.permission = reader.int32() as any;
+          break;
+        case 2:
+          message.enabled = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PermissionInfo {
+    return {
+      permission: isSet(object.permission)
+        ? permissionInfo_PermissionFromJSON(object.permission)
+        : 0,
+      enabled: isSet(object.enabled) ? Boolean(object.enabled) : false,
+    };
+  },
+
+  toJSON(message: PermissionInfo): unknown {
+    const obj: any = {};
+    message.permission !== undefined &&
+      (obj.permission = permissionInfo_PermissionToJSON(message.permission));
+    message.enabled !== undefined && (obj.enabled = message.enabled);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PermissionInfo>, I>>(
+    object: I
+  ): PermissionInfo {
+    const message = createBasePermissionInfo();
+    message.permission = object.permission ?? 0;
+    message.enabled = object.enabled ?? false;
+    return message;
+  },
+};
+
+function createBaseOptionMessage(): OptionMessage {
+  return {
+    imageQuality: 0,
+    lockAfterSessionEnd: 0,
+    showRemoteCursor: 0,
+    privacyMode: 0,
+    blockInput: 0,
+    customImageQuality: 0,
+    disableAudio: 0,
+    disableClipboard: 0,
+  };
+}
+
+export const OptionMessage = {
+  encode(message: OptionMessage, writer: Writer = Writer.create()): Writer {
+    if (message.imageQuality !== 0) {
+      writer.uint32(8).int32(message.imageQuality);
+    }
+    if (message.lockAfterSessionEnd !== 0) {
+      writer.uint32(16).int32(message.lockAfterSessionEnd);
+    }
+    if (message.showRemoteCursor !== 0) {
+      writer.uint32(24).int32(message.showRemoteCursor);
+    }
+    if (message.privacyMode !== 0) {
+      writer.uint32(32).int32(message.privacyMode);
+    }
+    if (message.blockInput !== 0) {
+      writer.uint32(40).int32(message.blockInput);
+    }
+    if (message.customImageQuality !== 0) {
+      writer.uint32(48).int32(message.customImageQuality);
+    }
+    if (message.disableAudio !== 0) {
+      writer.uint32(56).int32(message.disableAudio);
+    }
+    if (message.disableClipboard !== 0) {
+      writer.uint32(64).int32(message.disableClipboard);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): OptionMessage {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOptionMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.imageQuality = reader.int32() as any;
+          break;
+        case 2:
+          message.lockAfterSessionEnd = reader.int32() as any;
+          break;
+        case 3:
+          message.showRemoteCursor = reader.int32() as any;
+          break;
+        case 4:
+          message.privacyMode = reader.int32() as any;
+          break;
+        case 5:
+          message.blockInput = reader.int32() as any;
+          break;
+        case 6:
+          message.customImageQuality = reader.int32();
+          break;
+        case 7:
+          message.disableAudio = reader.int32() as any;
+          break;
+        case 8:
+          message.disableClipboard = reader.int32() as any;
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): OptionMessage {
+    return {
+      imageQuality: isSet(object.imageQuality)
+        ? imageQualityFromJSON(object.imageQuality)
+        : 0,
+      lockAfterSessionEnd: isSet(object.lockAfterSessionEnd)
+        ? optionMessage_BoolOptionFromJSON(object.lockAfterSessionEnd)
+        : 0,
+      showRemoteCursor: isSet(object.showRemoteCursor)
+        ? optionMessage_BoolOptionFromJSON(object.showRemoteCursor)
+        : 0,
+      privacyMode: isSet(object.privacyMode)
+        ? optionMessage_BoolOptionFromJSON(object.privacyMode)
+        : 0,
+      blockInput: isSet(object.blockInput)
+        ? optionMessage_BoolOptionFromJSON(object.blockInput)
+        : 0,
+      customImageQuality: isSet(object.customImageQuality)
+        ? Number(object.customImageQuality)
+        : 0,
+      disableAudio: isSet(object.disableAudio)
+        ? optionMessage_BoolOptionFromJSON(object.disableAudio)
+        : 0,
+      disableClipboard: isSet(object.disableClipboard)
+        ? optionMessage_BoolOptionFromJSON(object.disableClipboard)
+        : 0,
+    };
+  },
+
+  toJSON(message: OptionMessage): unknown {
+    const obj: any = {};
+    message.imageQuality !== undefined &&
+      (obj.imageQuality = imageQualityToJSON(message.imageQuality));
+    message.lockAfterSessionEnd !== undefined &&
+      (obj.lockAfterSessionEnd = optionMessage_BoolOptionToJSON(
+        message.lockAfterSessionEnd
+      ));
+    message.showRemoteCursor !== undefined &&
+      (obj.showRemoteCursor = optionMessage_BoolOptionToJSON(
+        message.showRemoteCursor
+      ));
+    message.privacyMode !== undefined &&
+      (obj.privacyMode = optionMessage_BoolOptionToJSON(message.privacyMode));
+    message.blockInput !== undefined &&
+      (obj.blockInput = optionMessage_BoolOptionToJSON(message.blockInput));
+    message.customImageQuality !== undefined &&
+      (obj.customImageQuality = Math.round(message.customImageQuality));
+    message.disableAudio !== undefined &&
+      (obj.disableAudio = optionMessage_BoolOptionToJSON(message.disableAudio));
+    message.disableClipboard !== undefined &&
+      (obj.disableClipboard = optionMessage_BoolOptionToJSON(
+        message.disableClipboard
+      ));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<OptionMessage>, I>>(
+    object: I
+  ): OptionMessage {
+    const message = createBaseOptionMessage();
+    message.imageQuality = object.imageQuality ?? 0;
+    message.lockAfterSessionEnd = object.lockAfterSessionEnd ?? 0;
+    message.showRemoteCursor = object.showRemoteCursor ?? 0;
+    message.privacyMode = object.privacyMode ?? 0;
+    message.blockInput = object.blockInput ?? 0;
+    message.customImageQuality = object.customImageQuality ?? 0;
+    message.disableAudio = object.disableAudio ?? 0;
+    message.disableClipboard = object.disableClipboard ?? 0;
+    return message;
+  },
+};
+
+function createBaseOptionResponse(): OptionResponse {
+  return { opt: undefined, error: "" };
+}
+
+export const OptionResponse = {
+  encode(message: OptionResponse, writer: Writer = Writer.create()): Writer {
+    if (message.opt !== undefined) {
+      OptionMessage.encode(message.opt, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.error !== "") {
+      writer.uint32(18).string(message.error);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): OptionResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOptionResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.opt = OptionMessage.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.error = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): OptionResponse {
+    return {
+      opt: isSet(object.opt) ? OptionMessage.fromJSON(object.opt) : undefined,
+      error: isSet(object.error) ? String(object.error) : "",
+    };
+  },
+
+  toJSON(message: OptionResponse): unknown {
+    const obj: any = {};
+    message.opt !== undefined &&
+      (obj.opt = message.opt ? OptionMessage.toJSON(message.opt) : undefined);
+    message.error !== undefined && (obj.error = message.error);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<OptionResponse>, I>>(
+    object: I
+  ): OptionResponse {
+    const message = createBaseOptionResponse();
+    message.opt =
+      object.opt !== undefined && object.opt !== null
+        ? OptionMessage.fromPartial(object.opt)
+        : undefined;
+    message.error = object.error ?? "";
+    return message;
+  },
+};
+
+function createBaseTestDelay(): TestDelay {
+  return { time: 0, fromClient: false };
+}
+
+export const TestDelay = {
+  encode(message: TestDelay, writer: Writer = Writer.create()): Writer {
+    if (message.time !== 0) {
+      writer.uint32(8).int64(message.time);
+    }
+    if (message.fromClient === true) {
+      writer.uint32(16).bool(message.fromClient);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): TestDelay {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTestDelay();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.time = longToNumber(reader.int64() as Long);
+          break;
+        case 2:
+          message.fromClient = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TestDelay {
+    return {
+      time: isSet(object.time) ? Number(object.time) : 0,
+      fromClient: isSet(object.fromClient) ? Boolean(object.fromClient) : false,
+    };
+  },
+
+  toJSON(message: TestDelay): unknown {
+    const obj: any = {};
+    message.time !== undefined && (obj.time = Math.round(message.time));
+    message.fromClient !== undefined && (obj.fromClient = message.fromClient);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TestDelay>, I>>(
+    object: I
+  ): TestDelay {
+    const message = createBaseTestDelay();
+    message.time = object.time ?? 0;
+    message.fromClient = object.fromClient ?? false;
+    return message;
+  },
+};
+
+function createBasePublicKey(): PublicKey {
+  return {
+    asymmetricValue: new Uint8Array(),
+    symmetricValue: new Uint8Array(),
+  };
+}
+
+export const PublicKey = {
+  encode(message: PublicKey, writer: Writer = Writer.create()): Writer {
+    if (message.asymmetricValue.length !== 0) {
+      writer.uint32(10).bytes(message.asymmetricValue);
+    }
+    if (message.symmetricValue.length !== 0) {
+      writer.uint32(18).bytes(message.symmetricValue);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PublicKey {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePublicKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.asymmetricValue = reader.bytes();
+          break;
+        case 2:
+          message.symmetricValue = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PublicKey {
+    return {
+      asymmetricValue: isSet(object.asymmetricValue)
+        ? bytesFromBase64(object.asymmetricValue)
+        : new Uint8Array(),
+      symmetricValue: isSet(object.symmetricValue)
+        ? bytesFromBase64(object.symmetricValue)
+        : new Uint8Array(),
+    };
+  },
+
+  toJSON(message: PublicKey): unknown {
+    const obj: any = {};
+    message.asymmetricValue !== undefined &&
+      (obj.asymmetricValue = base64FromBytes(
+        message.asymmetricValue !== undefined
+          ? message.asymmetricValue
+          : new Uint8Array()
+      ));
+    message.symmetricValue !== undefined &&
+      (obj.symmetricValue = base64FromBytes(
+        message.symmetricValue !== undefined
+          ? message.symmetricValue
+          : new Uint8Array()
+      ));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PublicKey>, I>>(
+    object: I
+  ): PublicKey {
+    const message = createBasePublicKey();
+    message.asymmetricValue = object.asymmetricValue ?? new Uint8Array();
+    message.symmetricValue = object.symmetricValue ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseSignedId(): SignedId {
+  return { id: new Uint8Array() };
+}
+
+export const SignedId = {
+  encode(message: SignedId, writer: Writer = Writer.create()): Writer {
+    if (message.id.length !== 0) {
+      writer.uint32(10).bytes(message.id);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): SignedId {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSignedId();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SignedId {
+    return {
+      id: isSet(object.id) ? bytesFromBase64(object.id) : new Uint8Array(),
+    };
+  },
+
+  toJSON(message: SignedId): unknown {
+    const obj: any = {};
+    message.id !== undefined &&
+      (obj.id = base64FromBytes(
+        message.id !== undefined ? message.id : new Uint8Array()
+      ));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SignedId>, I>>(object: I): SignedId {
+    const message = createBaseSignedId();
+    message.id = object.id ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseAudioFormat(): AudioFormat {
+  return { sampleRate: 0, channels: 0 };
+}
+
+export const AudioFormat = {
+  encode(message: AudioFormat, writer: Writer = Writer.create()): Writer {
+    if (message.sampleRate !== 0) {
+      writer.uint32(8).uint32(message.sampleRate);
+    }
+    if (message.channels !== 0) {
+      writer.uint32(16).uint32(message.channels);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): AudioFormat {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAudioFormat();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.sampleRate = reader.uint32();
+          break;
+        case 2:
+          message.channels = reader.uint32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AudioFormat {
+    return {
+      sampleRate: isSet(object.sampleRate) ? Number(object.sampleRate) : 0,
+      channels: isSet(object.channels) ? Number(object.channels) : 0,
+    };
+  },
+
+  toJSON(message: AudioFormat): unknown {
+    const obj: any = {};
+    message.sampleRate !== undefined &&
+      (obj.sampleRate = Math.round(message.sampleRate));
+    message.channels !== undefined &&
+      (obj.channels = Math.round(message.channels));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<AudioFormat>, I>>(
+    object: I
+  ): AudioFormat {
+    const message = createBaseAudioFormat();
+    message.sampleRate = object.sampleRate ?? 0;
+    message.channels = object.channels ?? 0;
+    return message;
+  },
+};
+
+function createBaseAudioFrame(): AudioFrame {
+  return { data: new Uint8Array() };
+}
+
+export const AudioFrame = {
+  encode(message: AudioFrame, writer: Writer = Writer.create()): Writer {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): AudioFrame {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAudioFrame();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AudioFrame {
+    return {
+      data: isSet(object.data)
+        ? bytesFromBase64(object.data)
+        : new Uint8Array(),
+    };
+  },
+
+  toJSON(message: AudioFrame): unknown {
+    const obj: any = {};
+    message.data !== undefined &&
+      (obj.data = base64FromBytes(
+        message.data !== undefined ? message.data : new Uint8Array()
+      ));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<AudioFrame>, I>>(
+    object: I
+  ): AudioFrame {
+    const message = createBaseAudioFrame();
+    message.data = object.data ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseMisc(): Misc {
+  return {
+    chatMessage: undefined,
+    switchDisplay: undefined,
+    permissionInfo: undefined,
+    option: undefined,
+    audioFormat: undefined,
+    closeReason: undefined,
+    refreshVideo: undefined,
+    optionResponse: undefined,
+  };
+}
+
+export const Misc = {
+  encode(message: Misc, writer: Writer = Writer.create()): Writer {
+    if (message.chatMessage !== undefined) {
+      ChatMessage.encode(
+        message.chatMessage,
+        writer.uint32(34).fork()
+      ).ldelim();
+    }
+    if (message.switchDisplay !== undefined) {
+      SwitchDisplay.encode(
+        message.switchDisplay,
+        writer.uint32(42).fork()
+      ).ldelim();
+    }
+    if (message.permissionInfo !== undefined) {
+      PermissionInfo.encode(
+        message.permissionInfo,
+        writer.uint32(50).fork()
+      ).ldelim();
+    }
+    if (message.option !== undefined) {
+      OptionMessage.encode(message.option, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.audioFormat !== undefined) {
+      AudioFormat.encode(
+        message.audioFormat,
+        writer.uint32(66).fork()
+      ).ldelim();
+    }
+    if (message.closeReason !== undefined) {
+      writer.uint32(74).string(message.closeReason);
+    }
+    if (message.refreshVideo !== undefined) {
+      writer.uint32(80).bool(message.refreshVideo);
+    }
+    if (message.optionResponse !== undefined) {
+      OptionResponse.encode(
+        message.optionResponse,
+        writer.uint32(90).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): Misc {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMisc();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 4:
+          message.chatMessage = ChatMessage.decode(reader, reader.uint32());
+          break;
+        case 5:
+          message.switchDisplay = SwitchDisplay.decode(reader, reader.uint32());
+          break;
+        case 6:
+          message.permissionInfo = PermissionInfo.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 7:
+          message.option = OptionMessage.decode(reader, reader.uint32());
+          break;
+        case 8:
+          message.audioFormat = AudioFormat.decode(reader, reader.uint32());
+          break;
+        case 9:
+          message.closeReason = reader.string();
+          break;
+        case 10:
+          message.refreshVideo = reader.bool();
+          break;
+        case 11:
+          message.optionResponse = OptionResponse.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Misc {
+    return {
+      chatMessage: isSet(object.chatMessage)
+        ? ChatMessage.fromJSON(object.chatMessage)
+        : undefined,
+      switchDisplay: isSet(object.switchDisplay)
+        ? SwitchDisplay.fromJSON(object.switchDisplay)
+        : undefined,
+      permissionInfo: isSet(object.permissionInfo)
+        ? PermissionInfo.fromJSON(object.permissionInfo)
+        : undefined,
+      option: isSet(object.option)
+        ? OptionMessage.fromJSON(object.option)
+        : undefined,
+      audioFormat: isSet(object.audioFormat)
+        ? AudioFormat.fromJSON(object.audioFormat)
+        : undefined,
+      closeReason: isSet(object.closeReason)
+        ? String(object.closeReason)
+        : undefined,
+      refreshVideo: isSet(object.refreshVideo)
+        ? Boolean(object.refreshVideo)
+        : undefined,
+      optionResponse: isSet(object.optionResponse)
+        ? OptionResponse.fromJSON(object.optionResponse)
+        : undefined,
+    };
+  },
+
+  toJSON(message: Misc): unknown {
+    const obj: any = {};
+    message.chatMessage !== undefined &&
+      (obj.chatMessage = message.chatMessage
+        ? ChatMessage.toJSON(message.chatMessage)
+        : undefined);
+    message.switchDisplay !== undefined &&
+      (obj.switchDisplay = message.switchDisplay
+        ? SwitchDisplay.toJSON(message.switchDisplay)
+        : undefined);
+    message.permissionInfo !== undefined &&
+      (obj.permissionInfo = message.permissionInfo
+        ? PermissionInfo.toJSON(message.permissionInfo)
+        : undefined);
+    message.option !== undefined &&
+      (obj.option = message.option
+        ? OptionMessage.toJSON(message.option)
+        : undefined);
+    message.audioFormat !== undefined &&
+      (obj.audioFormat = message.audioFormat
+        ? AudioFormat.toJSON(message.audioFormat)
+        : undefined);
+    message.closeReason !== undefined &&
+      (obj.closeReason = message.closeReason);
+    message.refreshVideo !== undefined &&
+      (obj.refreshVideo = message.refreshVideo);
+    message.optionResponse !== undefined &&
+      (obj.optionResponse = message.optionResponse
+        ? OptionResponse.toJSON(message.optionResponse)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Misc>, I>>(object: I): Misc {
+    const message = createBaseMisc();
+    message.chatMessage =
+      object.chatMessage !== undefined && object.chatMessage !== null
+        ? ChatMessage.fromPartial(object.chatMessage)
+        : undefined;
+    message.switchDisplay =
+      object.switchDisplay !== undefined && object.switchDisplay !== null
+        ? SwitchDisplay.fromPartial(object.switchDisplay)
+        : undefined;
+    message.permissionInfo =
+      object.permissionInfo !== undefined && object.permissionInfo !== null
+        ? PermissionInfo.fromPartial(object.permissionInfo)
+        : undefined;
+    message.option =
+      object.option !== undefined && object.option !== null
+        ? OptionMessage.fromPartial(object.option)
+        : undefined;
+    message.audioFormat =
+      object.audioFormat !== undefined && object.audioFormat !== null
+        ? AudioFormat.fromPartial(object.audioFormat)
+        : undefined;
+    message.closeReason = object.closeReason ?? undefined;
+    message.refreshVideo = object.refreshVideo ?? undefined;
+    message.optionResponse =
+      object.optionResponse !== undefined && object.optionResponse !== null
+        ? OptionResponse.fromPartial(object.optionResponse)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseMessage(): Message {
+  return {
+    signedId: undefined,
+    publicKey: undefined,
+    testDelay: undefined,
+    videoFrame: undefined,
+    loginRequest: undefined,
+    loginResponse: undefined,
+    hash: undefined,
+    mouseEvent: undefined,
+    audioFrame: undefined,
+    cursorData: undefined,
+    cursorPosition: undefined,
+    cursorId: undefined,
+    keyEvent: undefined,
+    clipboard: undefined,
+    fileAction: undefined,
+    fileResponse: undefined,
+    misc: undefined,
+  };
+}
+
+export const Message = {
+  encode(message: Message, writer: Writer = Writer.create()): Writer {
+    if (message.signedId !== undefined) {
+      SignedId.encode(message.signedId, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.publicKey !== undefined) {
+      PublicKey.encode(message.publicKey, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.testDelay !== undefined) {
+      TestDelay.encode(message.testDelay, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.videoFrame !== undefined) {
+      VideoFrame.encode(message.videoFrame, writer.uint32(50).fork()).ldelim();
+    }
+    if (message.loginRequest !== undefined) {
+      LoginRequest.encode(
+        message.loginRequest,
+        writer.uint32(58).fork()
+      ).ldelim();
+    }
+    if (message.loginResponse !== undefined) {
+      LoginResponse.encode(
+        message.loginResponse,
+        writer.uint32(66).fork()
+      ).ldelim();
+    }
+    if (message.hash !== undefined) {
+      Hash.encode(message.hash, writer.uint32(74).fork()).ldelim();
+    }
+    if (message.mouseEvent !== undefined) {
+      MouseEvent.encode(message.mouseEvent, writer.uint32(82).fork()).ldelim();
+    }
+    if (message.audioFrame !== undefined) {
+      AudioFrame.encode(message.audioFrame, writer.uint32(90).fork()).ldelim();
+    }
+    if (message.cursorData !== undefined) {
+      CursorData.encode(message.cursorData, writer.uint32(98).fork()).ldelim();
+    }
+    if (message.cursorPosition !== undefined) {
+      CursorPosition.encode(
+        message.cursorPosition,
+        writer.uint32(106).fork()
+      ).ldelim();
+    }
+    if (message.cursorId !== undefined) {
+      writer.uint32(112).uint64(message.cursorId);
+    }
+    if (message.keyEvent !== undefined) {
+      KeyEvent.encode(message.keyEvent, writer.uint32(122).fork()).ldelim();
+    }
+    if (message.clipboard !== undefined) {
+      Clipboard.encode(message.clipboard, writer.uint32(130).fork()).ldelim();
+    }
+    if (message.fileAction !== undefined) {
+      FileAction.encode(message.fileAction, writer.uint32(138).fork()).ldelim();
+    }
+    if (message.fileResponse !== undefined) {
+      FileResponse.encode(
+        message.fileResponse,
+        writer.uint32(146).fork()
+      ).ldelim();
+    }
+    if (message.misc !== undefined) {
+      Misc.encode(message.misc, writer.uint32(154).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): Message {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 3:
+          message.signedId = SignedId.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.publicKey = PublicKey.decode(reader, reader.uint32());
+          break;
+        case 5:
+          message.testDelay = TestDelay.decode(reader, reader.uint32());
+          break;
+        case 6:
+          message.videoFrame = VideoFrame.decode(reader, reader.uint32());
+          break;
+        case 7:
+          message.loginRequest = LoginRequest.decode(reader, reader.uint32());
+          break;
+        case 8:
+          message.loginResponse = LoginResponse.decode(reader, reader.uint32());
+          break;
+        case 9:
+          message.hash = Hash.decode(reader, reader.uint32());
+          break;
+        case 10:
+          message.mouseEvent = MouseEvent.decode(reader, reader.uint32());
+          break;
+        case 11:
+          message.audioFrame = AudioFrame.decode(reader, reader.uint32());
+          break;
+        case 12:
+          message.cursorData = CursorData.decode(reader, reader.uint32());
+          break;
+        case 13:
+          message.cursorPosition = CursorPosition.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 14:
+          message.cursorId = longToNumber(reader.uint64() as Long);
+          break;
+        case 15:
+          message.keyEvent = KeyEvent.decode(reader, reader.uint32());
+          break;
+        case 16:
+          message.clipboard = Clipboard.decode(reader, reader.uint32());
+          break;
+        case 17:
+          message.fileAction = FileAction.decode(reader, reader.uint32());
+          break;
+        case 18:
+          message.fileResponse = FileResponse.decode(reader, reader.uint32());
+          break;
+        case 19:
+          message.misc = Misc.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Message {
+    return {
+      signedId: isSet(object.signedId)
+        ? SignedId.fromJSON(object.signedId)
+        : undefined,
+      publicKey: isSet(object.publicKey)
+        ? PublicKey.fromJSON(object.publicKey)
+        : undefined,
+      testDelay: isSet(object.testDelay)
+        ? TestDelay.fromJSON(object.testDelay)
+        : undefined,
+      videoFrame: isSet(object.videoFrame)
+        ? VideoFrame.fromJSON(object.videoFrame)
+        : undefined,
+      loginRequest: isSet(object.loginRequest)
+        ? LoginRequest.fromJSON(object.loginRequest)
+        : undefined,
+      loginResponse: isSet(object.loginResponse)
+        ? LoginResponse.fromJSON(object.loginResponse)
+        : undefined,
+      hash: isSet(object.hash) ? Hash.fromJSON(object.hash) : undefined,
+      mouseEvent: isSet(object.mouseEvent)
+        ? MouseEvent.fromJSON(object.mouseEvent)
+        : undefined,
+      audioFrame: isSet(object.audioFrame)
+        ? AudioFrame.fromJSON(object.audioFrame)
+        : undefined,
+      cursorData: isSet(object.cursorData)
+        ? CursorData.fromJSON(object.cursorData)
+        : undefined,
+      cursorPosition: isSet(object.cursorPosition)
+        ? CursorPosition.fromJSON(object.cursorPosition)
+        : undefined,
+      cursorId: isSet(object.cursorId) ? Number(object.cursorId) : undefined,
+      keyEvent: isSet(object.keyEvent)
+        ? KeyEvent.fromJSON(object.keyEvent)
+        : undefined,
+      clipboard: isSet(object.clipboard)
+        ? Clipboard.fromJSON(object.clipboard)
+        : undefined,
+      fileAction: isSet(object.fileAction)
+        ? FileAction.fromJSON(object.fileAction)
+        : undefined,
+      fileResponse: isSet(object.fileResponse)
+        ? FileResponse.fromJSON(object.fileResponse)
+        : undefined,
+      misc: isSet(object.misc) ? Misc.fromJSON(object.misc) : undefined,
+    };
+  },
+
+  toJSON(message: Message): unknown {
+    const obj: any = {};
+    message.signedId !== undefined &&
+      (obj.signedId = message.signedId
+        ? SignedId.toJSON(message.signedId)
+        : undefined);
+    message.publicKey !== undefined &&
+      (obj.publicKey = message.publicKey
+        ? PublicKey.toJSON(message.publicKey)
+        : undefined);
+    message.testDelay !== undefined &&
+      (obj.testDelay = message.testDelay
+        ? TestDelay.toJSON(message.testDelay)
+        : undefined);
+    message.videoFrame !== undefined &&
+      (obj.videoFrame = message.videoFrame
+        ? VideoFrame.toJSON(message.videoFrame)
+        : undefined);
+    message.loginRequest !== undefined &&
+      (obj.loginRequest = message.loginRequest
+        ? LoginRequest.toJSON(message.loginRequest)
+        : undefined);
+    message.loginResponse !== undefined &&
+      (obj.loginResponse = message.loginResponse
+        ? LoginResponse.toJSON(message.loginResponse)
+        : undefined);
+    message.hash !== undefined &&
+      (obj.hash = message.hash ? Hash.toJSON(message.hash) : undefined);
+    message.mouseEvent !== undefined &&
+      (obj.mouseEvent = message.mouseEvent
+        ? MouseEvent.toJSON(message.mouseEvent)
+        : undefined);
+    message.audioFrame !== undefined &&
+      (obj.audioFrame = message.audioFrame
+        ? AudioFrame.toJSON(message.audioFrame)
+        : undefined);
+    message.cursorData !== undefined &&
+      (obj.cursorData = message.cursorData
+        ? CursorData.toJSON(message.cursorData)
+        : undefined);
+    message.cursorPosition !== undefined &&
+      (obj.cursorPosition = message.cursorPosition
+        ? CursorPosition.toJSON(message.cursorPosition)
+        : undefined);
+    message.cursorId !== undefined &&
+      (obj.cursorId = Math.round(message.cursorId));
+    message.keyEvent !== undefined &&
+      (obj.keyEvent = message.keyEvent
+        ? KeyEvent.toJSON(message.keyEvent)
+        : undefined);
+    message.clipboard !== undefined &&
+      (obj.clipboard = message.clipboard
+        ? Clipboard.toJSON(message.clipboard)
+        : undefined);
+    message.fileAction !== undefined &&
+      (obj.fileAction = message.fileAction
+        ? FileAction.toJSON(message.fileAction)
+        : undefined);
+    message.fileResponse !== undefined &&
+      (obj.fileResponse = message.fileResponse
+        ? FileResponse.toJSON(message.fileResponse)
+        : undefined);
+    message.misc !== undefined &&
+      (obj.misc = message.misc ? Misc.toJSON(message.misc) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Message>, I>>(object: I): Message {
+    const message = createBaseMessage();
+    message.signedId =
+      object.signedId !== undefined && object.signedId !== null
+        ? SignedId.fromPartial(object.signedId)
+        : undefined;
+    message.publicKey =
+      object.publicKey !== undefined && object.publicKey !== null
+        ? PublicKey.fromPartial(object.publicKey)
+        : undefined;
+    message.testDelay =
+      object.testDelay !== undefined && object.testDelay !== null
+        ? TestDelay.fromPartial(object.testDelay)
+        : undefined;
+    message.videoFrame =
+      object.videoFrame !== undefined && object.videoFrame !== null
+        ? VideoFrame.fromPartial(object.videoFrame)
+        : undefined;
+    message.loginRequest =
+      object.loginRequest !== undefined && object.loginRequest !== null
+        ? LoginRequest.fromPartial(object.loginRequest)
+        : undefined;
+    message.loginResponse =
+      object.loginResponse !== undefined && object.loginResponse !== null
+        ? LoginResponse.fromPartial(object.loginResponse)
+        : undefined;
+    message.hash =
+      object.hash !== undefined && object.hash !== null
+        ? Hash.fromPartial(object.hash)
+        : undefined;
+    message.mouseEvent =
+      object.mouseEvent !== undefined && object.mouseEvent !== null
+        ? MouseEvent.fromPartial(object.mouseEvent)
+        : undefined;
+    message.audioFrame =
+      object.audioFrame !== undefined && object.audioFrame !== null
+        ? AudioFrame.fromPartial(object.audioFrame)
+        : undefined;
+    message.cursorData =
+      object.cursorData !== undefined && object.cursorData !== null
+        ? CursorData.fromPartial(object.cursorData)
+        : undefined;
+    message.cursorPosition =
+      object.cursorPosition !== undefined && object.cursorPosition !== null
+        ? CursorPosition.fromPartial(object.cursorPosition)
+        : undefined;
+    message.cursorId = object.cursorId ?? undefined;
+    message.keyEvent =
+      object.keyEvent !== undefined && object.keyEvent !== null
+        ? KeyEvent.fromPartial(object.keyEvent)
+        : undefined;
+    message.clipboard =
+      object.clipboard !== undefined && object.clipboard !== null
+        ? Clipboard.fromPartial(object.clipboard)
+        : undefined;
+    message.fileAction =
+      object.fileAction !== undefined && object.fileAction !== null
+        ? FileAction.fromPartial(object.fileAction)
+        : undefined;
+    message.fileResponse =
+      object.fileResponse !== undefined && object.fileResponse !== null
+        ? FileResponse.fromPartial(object.fileResponse)
+        : undefined;
+    message.misc =
+      object.misc !== undefined && object.misc !== null
+        ? Misc.fromPartial(object.misc)
+        : undefined;
+    return message;
+  },
+};
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof self !== "undefined") return self;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+  throw "Unable to locate global object";
+})();
+
+const atob: (b64: string) => string =
+  globalThis.atob ||
+  ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
+function bytesFromBase64(b64: string): Uint8Array {
+  const bin = atob(b64);
+  const arr = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; ++i) {
+    arr[i] = bin.charCodeAt(i);
+  }
+  return arr;
+}
+
+const btoa: (bin: string) => string =
+  globalThis.btoa ||
+  ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
+function base64FromBytes(arr: Uint8Array): string {
+  const bin: string[] = [];
+  for (const byte of arr) {
+    bin.push(String.fromCharCode(byte));
+  }
+  return btoa(bin.join(""));
+}
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
+        Exclude<keyof I, KeysOfUnion<P>>,
+        never
+      >;
+
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
+// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
+if (util.Long !== Long) {
+  util.Long = Long as any;
+  configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
diff --git a/src/rendezvous.ts b/src/rendezvous.ts
new file mode 100644
index 000000000..9af1a4a44
--- /dev/null
+++ b/src/rendezvous.ts
@@ -0,0 +1,2252 @@
+/* eslint-disable */
+import { util, configure, Writer, Reader } from "protobufjs/minimal";
+import * as Long from "long";
+
+export const protobufPackage = "hbb";
+
+export enum ConnType {
+  DEFAULT_CONN = 0,
+  FILE_TRANSFER = 1,
+  PORT_FORWARD = 2,
+  RDP = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function connTypeFromJSON(object: any): ConnType {
+  switch (object) {
+    case 0:
+    case "DEFAULT_CONN":
+      return ConnType.DEFAULT_CONN;
+    case 1:
+    case "FILE_TRANSFER":
+      return ConnType.FILE_TRANSFER;
+    case 2:
+    case "PORT_FORWARD":
+      return ConnType.PORT_FORWARD;
+    case 3:
+    case "RDP":
+      return ConnType.RDP;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ConnType.UNRECOGNIZED;
+  }
+}
+
+export function connTypeToJSON(object: ConnType): string {
+  switch (object) {
+    case ConnType.DEFAULT_CONN:
+      return "DEFAULT_CONN";
+    case ConnType.FILE_TRANSFER:
+      return "FILE_TRANSFER";
+    case ConnType.PORT_FORWARD:
+      return "PORT_FORWARD";
+    case ConnType.RDP:
+      return "RDP";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export enum NatType {
+  UNKNOWN_NAT = 0,
+  ASYMMETRIC = 1,
+  SYMMETRIC = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function natTypeFromJSON(object: any): NatType {
+  switch (object) {
+    case 0:
+    case "UNKNOWN_NAT":
+      return NatType.UNKNOWN_NAT;
+    case 1:
+    case "ASYMMETRIC":
+      return NatType.ASYMMETRIC;
+    case 2:
+    case "SYMMETRIC":
+      return NatType.SYMMETRIC;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return NatType.UNRECOGNIZED;
+  }
+}
+
+export function natTypeToJSON(object: NatType): string {
+  switch (object) {
+    case NatType.UNKNOWN_NAT:
+      return "UNKNOWN_NAT";
+    case NatType.ASYMMETRIC:
+      return "ASYMMETRIC";
+    case NatType.SYMMETRIC:
+      return "SYMMETRIC";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export interface RegisterPeer {
+  id: string;
+  serial: number;
+}
+
+export interface RegisterPeerResponse {
+  requestPk: boolean;
+}
+
+export interface PunchHoleRequest {
+  id: string;
+  natType: NatType;
+  licenceKey: string;
+  connType: ConnType;
+}
+
+export interface PunchHole {
+  socketAddr: Uint8Array;
+  relayServer: string;
+  natType: NatType;
+}
+
+export interface TestNatRequest {
+  serial: number;
+}
+
+/** per my test, uint/int has no difference in encoding, int not good for negative, use sint for negative */
+export interface TestNatResponse {
+  port: number;
+  /** for mobile */
+  cu: ConfigUpdate | undefined;
+}
+
+export interface PunchHoleSent {
+  socketAddr: Uint8Array;
+  id: string;
+  relayServer: string;
+  natType: NatType;
+  version: string;
+}
+
+export interface RegisterPk {
+  id: string;
+  uuid: Uint8Array;
+  pk: Uint8Array;
+  oldId: string;
+}
+
+export interface RegisterPkResponse {
+  result: RegisterPkResponse_Result;
+}
+
+export enum RegisterPkResponse_Result {
+  UNKNOWN = 0,
+  OK = 1,
+  UUID_MISMATCH = 2,
+  ID_EXISTS = 3,
+  TOO_FREQUENT = 4,
+  INVALID_ID_FORMAT = 5,
+  NOT_SUPPORT = 6,
+  SERVER_ERROR = 7,
+  UNRECOGNIZED = -1,
+}
+
+export function registerPkResponse_ResultFromJSON(
+  object: any
+): RegisterPkResponse_Result {
+  switch (object) {
+    case 0:
+    case "UNKNOWN":
+      return RegisterPkResponse_Result.UNKNOWN;
+    case 1:
+    case "OK":
+      return RegisterPkResponse_Result.OK;
+    case 2:
+    case "UUID_MISMATCH":
+      return RegisterPkResponse_Result.UUID_MISMATCH;
+    case 3:
+    case "ID_EXISTS":
+      return RegisterPkResponse_Result.ID_EXISTS;
+    case 4:
+    case "TOO_FREQUENT":
+      return RegisterPkResponse_Result.TOO_FREQUENT;
+    case 5:
+    case "INVALID_ID_FORMAT":
+      return RegisterPkResponse_Result.INVALID_ID_FORMAT;
+    case 6:
+    case "NOT_SUPPORT":
+      return RegisterPkResponse_Result.NOT_SUPPORT;
+    case 7:
+    case "SERVER_ERROR":
+      return RegisterPkResponse_Result.SERVER_ERROR;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return RegisterPkResponse_Result.UNRECOGNIZED;
+  }
+}
+
+export function registerPkResponse_ResultToJSON(
+  object: RegisterPkResponse_Result
+): string {
+  switch (object) {
+    case RegisterPkResponse_Result.UNKNOWN:
+      return "UNKNOWN";
+    case RegisterPkResponse_Result.OK:
+      return "OK";
+    case RegisterPkResponse_Result.UUID_MISMATCH:
+      return "UUID_MISMATCH";
+    case RegisterPkResponse_Result.ID_EXISTS:
+      return "ID_EXISTS";
+    case RegisterPkResponse_Result.TOO_FREQUENT:
+      return "TOO_FREQUENT";
+    case RegisterPkResponse_Result.INVALID_ID_FORMAT:
+      return "INVALID_ID_FORMAT";
+    case RegisterPkResponse_Result.NOT_SUPPORT:
+      return "NOT_SUPPORT";
+    case RegisterPkResponse_Result.SERVER_ERROR:
+      return "SERVER_ERROR";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export interface PunchHoleResponse {
+  socketAddr: Uint8Array;
+  pk: Uint8Array;
+  failure: PunchHoleResponse_Failure;
+  relayServer: string;
+  natType: NatType | undefined;
+  isLocal: boolean | undefined;
+  otherFailure: string;
+}
+
+export enum PunchHoleResponse_Failure {
+  UNKNOWN = 0,
+  ID_NOT_EXIST = 1,
+  OFFLINE = 2,
+  LICENSE_MISMATCH = 3,
+  LICENSE_OVERUSE = 4,
+  UNRECOGNIZED = -1,
+}
+
+export function punchHoleResponse_FailureFromJSON(
+  object: any
+): PunchHoleResponse_Failure {
+  switch (object) {
+    case 0:
+    case "UNKNOWN":
+      return PunchHoleResponse_Failure.UNKNOWN;
+    case 1:
+    case "ID_NOT_EXIST":
+      return PunchHoleResponse_Failure.ID_NOT_EXIST;
+    case 2:
+    case "OFFLINE":
+      return PunchHoleResponse_Failure.OFFLINE;
+    case 3:
+    case "LICENSE_MISMATCH":
+      return PunchHoleResponse_Failure.LICENSE_MISMATCH;
+    case 4:
+    case "LICENSE_OVERUSE":
+      return PunchHoleResponse_Failure.LICENSE_OVERUSE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return PunchHoleResponse_Failure.UNRECOGNIZED;
+  }
+}
+
+export function punchHoleResponse_FailureToJSON(
+  object: PunchHoleResponse_Failure
+): string {
+  switch (object) {
+    case PunchHoleResponse_Failure.UNKNOWN:
+      return "UNKNOWN";
+    case PunchHoleResponse_Failure.ID_NOT_EXIST:
+      return "ID_NOT_EXIST";
+    case PunchHoleResponse_Failure.OFFLINE:
+      return "OFFLINE";
+    case PunchHoleResponse_Failure.LICENSE_MISMATCH:
+      return "LICENSE_MISMATCH";
+    case PunchHoleResponse_Failure.LICENSE_OVERUSE:
+      return "LICENSE_OVERUSE";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+export interface ConfigUpdate {
+  serial: number;
+  rendezvousServers: string[];
+}
+
+export interface RequestRelay {
+  id: string;
+  uuid: string;
+  socketAddr: Uint8Array;
+  relayServer: string;
+  secure: boolean;
+  licenceKey: string;
+  connType: ConnType;
+}
+
+export interface RelayResponse {
+  socketAddr: Uint8Array;
+  uuid: string;
+  relayServer: string;
+  id: string | undefined;
+  pk: Uint8Array | undefined;
+  refuseReason: string;
+  version: string;
+}
+
+export interface SoftwareUpdate {
+  url: string;
+}
+
+/**
+ * if in same intranet, punch hole won't work both for udp and tcp,
+ * even some router has below connection error if we connect itself,
+ *  { kind: Other, error: "could not resolve to any address" },
+ * so we request local address to connect.
+ */
+export interface FetchLocalAddr {
+  socketAddr: Uint8Array;
+  relayServer: string;
+}
+
+export interface LocalAddr {
+  socketAddr: Uint8Array;
+  localAddr: Uint8Array;
+  relayServer: string;
+  id: string;
+  version: string;
+}
+
+export interface PeerDiscovery {
+  cmd: string;
+  mac: string;
+  id: string;
+  username: string;
+  hostname: string;
+  platform: string;
+  misc: string;
+}
+
+export interface RendezvousMessage {
+  registerPeer: RegisterPeer | undefined;
+  registerPeerResponse: RegisterPeerResponse | undefined;
+  punchHoleRequest: PunchHoleRequest | undefined;
+  punchHole: PunchHole | undefined;
+  punchHoleSent: PunchHoleSent | undefined;
+  punchHoleResponse: PunchHoleResponse | undefined;
+  fetchLocalAddr: FetchLocalAddr | undefined;
+  localAddr: LocalAddr | undefined;
+  configureUpdate: ConfigUpdate | undefined;
+  registerPk: RegisterPk | undefined;
+  registerPkResponse: RegisterPkResponse | undefined;
+  softwareUpdate: SoftwareUpdate | undefined;
+  requestRelay: RequestRelay | undefined;
+  relayResponse: RelayResponse | undefined;
+  testNatRequest: TestNatRequest | undefined;
+  testNatResponse: TestNatResponse | undefined;
+  peerDiscovery: PeerDiscovery | undefined;
+}
+
+function createBaseRegisterPeer(): RegisterPeer {
+  return { id: "", serial: 0 };
+}
+
+export const RegisterPeer = {
+  encode(message: RegisterPeer, writer: Writer = Writer.create()): Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.serial !== 0) {
+      writer.uint32(16).int32(message.serial);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RegisterPeer {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRegisterPeer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+        case 2:
+          message.serial = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RegisterPeer {
+    return {
+      id: isSet(object.id) ? String(object.id) : "",
+      serial: isSet(object.serial) ? Number(object.serial) : 0,
+    };
+  },
+
+  toJSON(message: RegisterPeer): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id);
+    message.serial !== undefined && (obj.serial = Math.round(message.serial));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RegisterPeer>, I>>(
+    object: I
+  ): RegisterPeer {
+    const message = createBaseRegisterPeer();
+    message.id = object.id ?? "";
+    message.serial = object.serial ?? 0;
+    return message;
+  },
+};
+
+function createBaseRegisterPeerResponse(): RegisterPeerResponse {
+  return { requestPk: false };
+}
+
+export const RegisterPeerResponse = {
+  encode(
+    message: RegisterPeerResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.requestPk === true) {
+      writer.uint32(16).bool(message.requestPk);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RegisterPeerResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRegisterPeerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          message.requestPk = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RegisterPeerResponse {
+    return {
+      requestPk: isSet(object.requestPk) ? Boolean(object.requestPk) : false,
+    };
+  },
+
+  toJSON(message: RegisterPeerResponse): unknown {
+    const obj: any = {};
+    message.requestPk !== undefined && (obj.requestPk = message.requestPk);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RegisterPeerResponse>, I>>(
+    object: I
+  ): RegisterPeerResponse {
+    const message = createBaseRegisterPeerResponse();
+    message.requestPk = object.requestPk ?? false;
+    return message;
+  },
+};
+
+function createBasePunchHoleRequest(): PunchHoleRequest {
+  return { id: "", natType: 0, licenceKey: "", connType: 0 };
+}
+
+export const PunchHoleRequest = {
+  encode(message: PunchHoleRequest, writer: Writer = Writer.create()): Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.natType !== 0) {
+      writer.uint32(16).int32(message.natType);
+    }
+    if (message.licenceKey !== "") {
+      writer.uint32(26).string(message.licenceKey);
+    }
+    if (message.connType !== 0) {
+      writer.uint32(32).int32(message.connType);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PunchHoleRequest {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePunchHoleRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+        case 2:
+          message.natType = reader.int32() as any;
+          break;
+        case 3:
+          message.licenceKey = reader.string();
+          break;
+        case 4:
+          message.connType = reader.int32() as any;
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PunchHoleRequest {
+    return {
+      id: isSet(object.id) ? String(object.id) : "",
+      natType: isSet(object.natType) ? natTypeFromJSON(object.natType) : 0,
+      licenceKey: isSet(object.licenceKey) ? String(object.licenceKey) : "",
+      connType: isSet(object.connType) ? connTypeFromJSON(object.connType) : 0,
+    };
+  },
+
+  toJSON(message: PunchHoleRequest): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id);
+    message.natType !== undefined &&
+      (obj.natType = natTypeToJSON(message.natType));
+    message.licenceKey !== undefined && (obj.licenceKey = message.licenceKey);
+    message.connType !== undefined &&
+      (obj.connType = connTypeToJSON(message.connType));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PunchHoleRequest>, I>>(
+    object: I
+  ): PunchHoleRequest {
+    const message = createBasePunchHoleRequest();
+    message.id = object.id ?? "";
+    message.natType = object.natType ?? 0;
+    message.licenceKey = object.licenceKey ?? "";
+    message.connType = object.connType ?? 0;
+    return message;
+  },
+};
+
+function createBasePunchHole(): PunchHole {
+  return { socketAddr: new Uint8Array(), relayServer: "", natType: 0 };
+}
+
+export const PunchHole = {
+  encode(message: PunchHole, writer: Writer = Writer.create()): Writer {
+    if (message.socketAddr.length !== 0) {
+      writer.uint32(10).bytes(message.socketAddr);
+    }
+    if (message.relayServer !== "") {
+      writer.uint32(18).string(message.relayServer);
+    }
+    if (message.natType !== 0) {
+      writer.uint32(24).int32(message.natType);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PunchHole {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePunchHole();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.socketAddr = reader.bytes();
+          break;
+        case 2:
+          message.relayServer = reader.string();
+          break;
+        case 3:
+          message.natType = reader.int32() as any;
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PunchHole {
+    return {
+      socketAddr: isSet(object.socketAddr)
+        ? bytesFromBase64(object.socketAddr)
+        : new Uint8Array(),
+      relayServer: isSet(object.relayServer) ? String(object.relayServer) : "",
+      natType: isSet(object.natType) ? natTypeFromJSON(object.natType) : 0,
+    };
+  },
+
+  toJSON(message: PunchHole): unknown {
+    const obj: any = {};
+    message.socketAddr !== undefined &&
+      (obj.socketAddr = base64FromBytes(
+        message.socketAddr !== undefined ? message.socketAddr : new Uint8Array()
+      ));
+    message.relayServer !== undefined &&
+      (obj.relayServer = message.relayServer);
+    message.natType !== undefined &&
+      (obj.natType = natTypeToJSON(message.natType));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PunchHole>, I>>(
+    object: I
+  ): PunchHole {
+    const message = createBasePunchHole();
+    message.socketAddr = object.socketAddr ?? new Uint8Array();
+    message.relayServer = object.relayServer ?? "";
+    message.natType = object.natType ?? 0;
+    return message;
+  },
+};
+
+function createBaseTestNatRequest(): TestNatRequest {
+  return { serial: 0 };
+}
+
+export const TestNatRequest = {
+  encode(message: TestNatRequest, writer: Writer = Writer.create()): Writer {
+    if (message.serial !== 0) {
+      writer.uint32(8).int32(message.serial);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): TestNatRequest {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTestNatRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.serial = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TestNatRequest {
+    return {
+      serial: isSet(object.serial) ? Number(object.serial) : 0,
+    };
+  },
+
+  toJSON(message: TestNatRequest): unknown {
+    const obj: any = {};
+    message.serial !== undefined && (obj.serial = Math.round(message.serial));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TestNatRequest>, I>>(
+    object: I
+  ): TestNatRequest {
+    const message = createBaseTestNatRequest();
+    message.serial = object.serial ?? 0;
+    return message;
+  },
+};
+
+function createBaseTestNatResponse(): TestNatResponse {
+  return { port: 0, cu: undefined };
+}
+
+export const TestNatResponse = {
+  encode(message: TestNatResponse, writer: Writer = Writer.create()): Writer {
+    if (message.port !== 0) {
+      writer.uint32(8).int32(message.port);
+    }
+    if (message.cu !== undefined) {
+      ConfigUpdate.encode(message.cu, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): TestNatResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTestNatResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.port = reader.int32();
+          break;
+        case 2:
+          message.cu = ConfigUpdate.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TestNatResponse {
+    return {
+      port: isSet(object.port) ? Number(object.port) : 0,
+      cu: isSet(object.cu) ? ConfigUpdate.fromJSON(object.cu) : undefined,
+    };
+  },
+
+  toJSON(message: TestNatResponse): unknown {
+    const obj: any = {};
+    message.port !== undefined && (obj.port = Math.round(message.port));
+    message.cu !== undefined &&
+      (obj.cu = message.cu ? ConfigUpdate.toJSON(message.cu) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TestNatResponse>, I>>(
+    object: I
+  ): TestNatResponse {
+    const message = createBaseTestNatResponse();
+    message.port = object.port ?? 0;
+    message.cu =
+      object.cu !== undefined && object.cu !== null
+        ? ConfigUpdate.fromPartial(object.cu)
+        : undefined;
+    return message;
+  },
+};
+
+function createBasePunchHoleSent(): PunchHoleSent {
+  return {
+    socketAddr: new Uint8Array(),
+    id: "",
+    relayServer: "",
+    natType: 0,
+    version: "",
+  };
+}
+
+export const PunchHoleSent = {
+  encode(message: PunchHoleSent, writer: Writer = Writer.create()): Writer {
+    if (message.socketAddr.length !== 0) {
+      writer.uint32(10).bytes(message.socketAddr);
+    }
+    if (message.id !== "") {
+      writer.uint32(18).string(message.id);
+    }
+    if (message.relayServer !== "") {
+      writer.uint32(26).string(message.relayServer);
+    }
+    if (message.natType !== 0) {
+      writer.uint32(32).int32(message.natType);
+    }
+    if (message.version !== "") {
+      writer.uint32(42).string(message.version);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PunchHoleSent {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePunchHoleSent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.socketAddr = reader.bytes();
+          break;
+        case 2:
+          message.id = reader.string();
+          break;
+        case 3:
+          message.relayServer = reader.string();
+          break;
+        case 4:
+          message.natType = reader.int32() as any;
+          break;
+        case 5:
+          message.version = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PunchHoleSent {
+    return {
+      socketAddr: isSet(object.socketAddr)
+        ? bytesFromBase64(object.socketAddr)
+        : new Uint8Array(),
+      id: isSet(object.id) ? String(object.id) : "",
+      relayServer: isSet(object.relayServer) ? String(object.relayServer) : "",
+      natType: isSet(object.natType) ? natTypeFromJSON(object.natType) : 0,
+      version: isSet(object.version) ? String(object.version) : "",
+    };
+  },
+
+  toJSON(message: PunchHoleSent): unknown {
+    const obj: any = {};
+    message.socketAddr !== undefined &&
+      (obj.socketAddr = base64FromBytes(
+        message.socketAddr !== undefined ? message.socketAddr : new Uint8Array()
+      ));
+    message.id !== undefined && (obj.id = message.id);
+    message.relayServer !== undefined &&
+      (obj.relayServer = message.relayServer);
+    message.natType !== undefined &&
+      (obj.natType = natTypeToJSON(message.natType));
+    message.version !== undefined && (obj.version = message.version);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PunchHoleSent>, I>>(
+    object: I
+  ): PunchHoleSent {
+    const message = createBasePunchHoleSent();
+    message.socketAddr = object.socketAddr ?? new Uint8Array();
+    message.id = object.id ?? "";
+    message.relayServer = object.relayServer ?? "";
+    message.natType = object.natType ?? 0;
+    message.version = object.version ?? "";
+    return message;
+  },
+};
+
+function createBaseRegisterPk(): RegisterPk {
+  return { id: "", uuid: new Uint8Array(), pk: new Uint8Array(), oldId: "" };
+}
+
+export const RegisterPk = {
+  encode(message: RegisterPk, writer: Writer = Writer.create()): Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.uuid.length !== 0) {
+      writer.uint32(18).bytes(message.uuid);
+    }
+    if (message.pk.length !== 0) {
+      writer.uint32(26).bytes(message.pk);
+    }
+    if (message.oldId !== "") {
+      writer.uint32(34).string(message.oldId);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RegisterPk {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRegisterPk();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+        case 2:
+          message.uuid = reader.bytes();
+          break;
+        case 3:
+          message.pk = reader.bytes();
+          break;
+        case 4:
+          message.oldId = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RegisterPk {
+    return {
+      id: isSet(object.id) ? String(object.id) : "",
+      uuid: isSet(object.uuid)
+        ? bytesFromBase64(object.uuid)
+        : new Uint8Array(),
+      pk: isSet(object.pk) ? bytesFromBase64(object.pk) : new Uint8Array(),
+      oldId: isSet(object.oldId) ? String(object.oldId) : "",
+    };
+  },
+
+  toJSON(message: RegisterPk): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id);
+    message.uuid !== undefined &&
+      (obj.uuid = base64FromBytes(
+        message.uuid !== undefined ? message.uuid : new Uint8Array()
+      ));
+    message.pk !== undefined &&
+      (obj.pk = base64FromBytes(
+        message.pk !== undefined ? message.pk : new Uint8Array()
+      ));
+    message.oldId !== undefined && (obj.oldId = message.oldId);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RegisterPk>, I>>(
+    object: I
+  ): RegisterPk {
+    const message = createBaseRegisterPk();
+    message.id = object.id ?? "";
+    message.uuid = object.uuid ?? new Uint8Array();
+    message.pk = object.pk ?? new Uint8Array();
+    message.oldId = object.oldId ?? "";
+    return message;
+  },
+};
+
+function createBaseRegisterPkResponse(): RegisterPkResponse {
+  return { result: 0 };
+}
+
+export const RegisterPkResponse = {
+  encode(
+    message: RegisterPkResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.result !== 0) {
+      writer.uint32(8).int32(message.result);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RegisterPkResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRegisterPkResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.result = reader.int32() as any;
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RegisterPkResponse {
+    return {
+      result: isSet(object.result)
+        ? registerPkResponse_ResultFromJSON(object.result)
+        : 0,
+    };
+  },
+
+  toJSON(message: RegisterPkResponse): unknown {
+    const obj: any = {};
+    message.result !== undefined &&
+      (obj.result = registerPkResponse_ResultToJSON(message.result));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RegisterPkResponse>, I>>(
+    object: I
+  ): RegisterPkResponse {
+    const message = createBaseRegisterPkResponse();
+    message.result = object.result ?? 0;
+    return message;
+  },
+};
+
+function createBasePunchHoleResponse(): PunchHoleResponse {
+  return {
+    socketAddr: new Uint8Array(),
+    pk: new Uint8Array(),
+    failure: 0,
+    relayServer: "",
+    natType: undefined,
+    isLocal: undefined,
+    otherFailure: "",
+  };
+}
+
+export const PunchHoleResponse = {
+  encode(message: PunchHoleResponse, writer: Writer = Writer.create()): Writer {
+    if (message.socketAddr.length !== 0) {
+      writer.uint32(10).bytes(message.socketAddr);
+    }
+    if (message.pk.length !== 0) {
+      writer.uint32(18).bytes(message.pk);
+    }
+    if (message.failure !== 0) {
+      writer.uint32(24).int32(message.failure);
+    }
+    if (message.relayServer !== "") {
+      writer.uint32(34).string(message.relayServer);
+    }
+    if (message.natType !== undefined) {
+      writer.uint32(40).int32(message.natType);
+    }
+    if (message.isLocal !== undefined) {
+      writer.uint32(48).bool(message.isLocal);
+    }
+    if (message.otherFailure !== "") {
+      writer.uint32(58).string(message.otherFailure);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PunchHoleResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePunchHoleResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.socketAddr = reader.bytes();
+          break;
+        case 2:
+          message.pk = reader.bytes();
+          break;
+        case 3:
+          message.failure = reader.int32() as any;
+          break;
+        case 4:
+          message.relayServer = reader.string();
+          break;
+        case 5:
+          message.natType = reader.int32() as any;
+          break;
+        case 6:
+          message.isLocal = reader.bool();
+          break;
+        case 7:
+          message.otherFailure = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PunchHoleResponse {
+    return {
+      socketAddr: isSet(object.socketAddr)
+        ? bytesFromBase64(object.socketAddr)
+        : new Uint8Array(),
+      pk: isSet(object.pk) ? bytesFromBase64(object.pk) : new Uint8Array(),
+      failure: isSet(object.failure)
+        ? punchHoleResponse_FailureFromJSON(object.failure)
+        : 0,
+      relayServer: isSet(object.relayServer) ? String(object.relayServer) : "",
+      natType: isSet(object.natType)
+        ? natTypeFromJSON(object.natType)
+        : undefined,
+      isLocal: isSet(object.isLocal) ? Boolean(object.isLocal) : undefined,
+      otherFailure: isSet(object.otherFailure)
+        ? String(object.otherFailure)
+        : "",
+    };
+  },
+
+  toJSON(message: PunchHoleResponse): unknown {
+    const obj: any = {};
+    message.socketAddr !== undefined &&
+      (obj.socketAddr = base64FromBytes(
+        message.socketAddr !== undefined ? message.socketAddr : new Uint8Array()
+      ));
+    message.pk !== undefined &&
+      (obj.pk = base64FromBytes(
+        message.pk !== undefined ? message.pk : new Uint8Array()
+      ));
+    message.failure !== undefined &&
+      (obj.failure = punchHoleResponse_FailureToJSON(message.failure));
+    message.relayServer !== undefined &&
+      (obj.relayServer = message.relayServer);
+    message.natType !== undefined &&
+      (obj.natType =
+        message.natType !== undefined
+          ? natTypeToJSON(message.natType)
+          : undefined);
+    message.isLocal !== undefined && (obj.isLocal = message.isLocal);
+    message.otherFailure !== undefined &&
+      (obj.otherFailure = message.otherFailure);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PunchHoleResponse>, I>>(
+    object: I
+  ): PunchHoleResponse {
+    const message = createBasePunchHoleResponse();
+    message.socketAddr = object.socketAddr ?? new Uint8Array();
+    message.pk = object.pk ?? new Uint8Array();
+    message.failure = object.failure ?? 0;
+    message.relayServer = object.relayServer ?? "";
+    message.natType = object.natType ?? undefined;
+    message.isLocal = object.isLocal ?? undefined;
+    message.otherFailure = object.otherFailure ?? "";
+    return message;
+  },
+};
+
+function createBaseConfigUpdate(): ConfigUpdate {
+  return { serial: 0, rendezvousServers: [] };
+}
+
+export const ConfigUpdate = {
+  encode(message: ConfigUpdate, writer: Writer = Writer.create()): Writer {
+    if (message.serial !== 0) {
+      writer.uint32(8).int32(message.serial);
+    }
+    for (const v of message.rendezvousServers) {
+      writer.uint32(18).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): ConfigUpdate {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfigUpdate();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.serial = reader.int32();
+          break;
+        case 2:
+          message.rendezvousServers.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ConfigUpdate {
+    return {
+      serial: isSet(object.serial) ? Number(object.serial) : 0,
+      rendezvousServers: Array.isArray(object?.rendezvousServers)
+        ? object.rendezvousServers.map((e: any) => String(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ConfigUpdate): unknown {
+    const obj: any = {};
+    message.serial !== undefined && (obj.serial = Math.round(message.serial));
+    if (message.rendezvousServers) {
+      obj.rendezvousServers = message.rendezvousServers.map((e) => e);
+    } else {
+      obj.rendezvousServers = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ConfigUpdate>, I>>(
+    object: I
+  ): ConfigUpdate {
+    const message = createBaseConfigUpdate();
+    message.serial = object.serial ?? 0;
+    message.rendezvousServers = object.rendezvousServers?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseRequestRelay(): RequestRelay {
+  return {
+    id: "",
+    uuid: "",
+    socketAddr: new Uint8Array(),
+    relayServer: "",
+    secure: false,
+    licenceKey: "",
+    connType: 0,
+  };
+}
+
+export const RequestRelay = {
+  encode(message: RequestRelay, writer: Writer = Writer.create()): Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.uuid !== "") {
+      writer.uint32(18).string(message.uuid);
+    }
+    if (message.socketAddr.length !== 0) {
+      writer.uint32(26).bytes(message.socketAddr);
+    }
+    if (message.relayServer !== "") {
+      writer.uint32(34).string(message.relayServer);
+    }
+    if (message.secure === true) {
+      writer.uint32(40).bool(message.secure);
+    }
+    if (message.licenceKey !== "") {
+      writer.uint32(50).string(message.licenceKey);
+    }
+    if (message.connType !== 0) {
+      writer.uint32(56).int32(message.connType);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RequestRelay {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRequestRelay();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+        case 2:
+          message.uuid = reader.string();
+          break;
+        case 3:
+          message.socketAddr = reader.bytes();
+          break;
+        case 4:
+          message.relayServer = reader.string();
+          break;
+        case 5:
+          message.secure = reader.bool();
+          break;
+        case 6:
+          message.licenceKey = reader.string();
+          break;
+        case 7:
+          message.connType = reader.int32() as any;
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RequestRelay {
+    return {
+      id: isSet(object.id) ? String(object.id) : "",
+      uuid: isSet(object.uuid) ? String(object.uuid) : "",
+      socketAddr: isSet(object.socketAddr)
+        ? bytesFromBase64(object.socketAddr)
+        : new Uint8Array(),
+      relayServer: isSet(object.relayServer) ? String(object.relayServer) : "",
+      secure: isSet(object.secure) ? Boolean(object.secure) : false,
+      licenceKey: isSet(object.licenceKey) ? String(object.licenceKey) : "",
+      connType: isSet(object.connType) ? connTypeFromJSON(object.connType) : 0,
+    };
+  },
+
+  toJSON(message: RequestRelay): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id);
+    message.uuid !== undefined && (obj.uuid = message.uuid);
+    message.socketAddr !== undefined &&
+      (obj.socketAddr = base64FromBytes(
+        message.socketAddr !== undefined ? message.socketAddr : new Uint8Array()
+      ));
+    message.relayServer !== undefined &&
+      (obj.relayServer = message.relayServer);
+    message.secure !== undefined && (obj.secure = message.secure);
+    message.licenceKey !== undefined && (obj.licenceKey = message.licenceKey);
+    message.connType !== undefined &&
+      (obj.connType = connTypeToJSON(message.connType));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RequestRelay>, I>>(
+    object: I
+  ): RequestRelay {
+    const message = createBaseRequestRelay();
+    message.id = object.id ?? "";
+    message.uuid = object.uuid ?? "";
+    message.socketAddr = object.socketAddr ?? new Uint8Array();
+    message.relayServer = object.relayServer ?? "";
+    message.secure = object.secure ?? false;
+    message.licenceKey = object.licenceKey ?? "";
+    message.connType = object.connType ?? 0;
+    return message;
+  },
+};
+
+function createBaseRelayResponse(): RelayResponse {
+  return {
+    socketAddr: new Uint8Array(),
+    uuid: "",
+    relayServer: "",
+    id: undefined,
+    pk: undefined,
+    refuseReason: "",
+    version: "",
+  };
+}
+
+export const RelayResponse = {
+  encode(message: RelayResponse, writer: Writer = Writer.create()): Writer {
+    if (message.socketAddr.length !== 0) {
+      writer.uint32(10).bytes(message.socketAddr);
+    }
+    if (message.uuid !== "") {
+      writer.uint32(18).string(message.uuid);
+    }
+    if (message.relayServer !== "") {
+      writer.uint32(26).string(message.relayServer);
+    }
+    if (message.id !== undefined) {
+      writer.uint32(34).string(message.id);
+    }
+    if (message.pk !== undefined) {
+      writer.uint32(42).bytes(message.pk);
+    }
+    if (message.refuseReason !== "") {
+      writer.uint32(50).string(message.refuseReason);
+    }
+    if (message.version !== "") {
+      writer.uint32(58).string(message.version);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RelayResponse {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRelayResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.socketAddr = reader.bytes();
+          break;
+        case 2:
+          message.uuid = reader.string();
+          break;
+        case 3:
+          message.relayServer = reader.string();
+          break;
+        case 4:
+          message.id = reader.string();
+          break;
+        case 5:
+          message.pk = reader.bytes();
+          break;
+        case 6:
+          message.refuseReason = reader.string();
+          break;
+        case 7:
+          message.version = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RelayResponse {
+    return {
+      socketAddr: isSet(object.socketAddr)
+        ? bytesFromBase64(object.socketAddr)
+        : new Uint8Array(),
+      uuid: isSet(object.uuid) ? String(object.uuid) : "",
+      relayServer: isSet(object.relayServer) ? String(object.relayServer) : "",
+      id: isSet(object.id) ? String(object.id) : undefined,
+      pk: isSet(object.pk) ? bytesFromBase64(object.pk) : undefined,
+      refuseReason: isSet(object.refuseReason)
+        ? String(object.refuseReason)
+        : "",
+      version: isSet(object.version) ? String(object.version) : "",
+    };
+  },
+
+  toJSON(message: RelayResponse): unknown {
+    const obj: any = {};
+    message.socketAddr !== undefined &&
+      (obj.socketAddr = base64FromBytes(
+        message.socketAddr !== undefined ? message.socketAddr : new Uint8Array()
+      ));
+    message.uuid !== undefined && (obj.uuid = message.uuid);
+    message.relayServer !== undefined &&
+      (obj.relayServer = message.relayServer);
+    message.id !== undefined && (obj.id = message.id);
+    message.pk !== undefined &&
+      (obj.pk =
+        message.pk !== undefined ? base64FromBytes(message.pk) : undefined);
+    message.refuseReason !== undefined &&
+      (obj.refuseReason = message.refuseReason);
+    message.version !== undefined && (obj.version = message.version);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RelayResponse>, I>>(
+    object: I
+  ): RelayResponse {
+    const message = createBaseRelayResponse();
+    message.socketAddr = object.socketAddr ?? new Uint8Array();
+    message.uuid = object.uuid ?? "";
+    message.relayServer = object.relayServer ?? "";
+    message.id = object.id ?? undefined;
+    message.pk = object.pk ?? undefined;
+    message.refuseReason = object.refuseReason ?? "";
+    message.version = object.version ?? "";
+    return message;
+  },
+};
+
+function createBaseSoftwareUpdate(): SoftwareUpdate {
+  return { url: "" };
+}
+
+export const SoftwareUpdate = {
+  encode(message: SoftwareUpdate, writer: Writer = Writer.create()): Writer {
+    if (message.url !== "") {
+      writer.uint32(10).string(message.url);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): SoftwareUpdate {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSoftwareUpdate();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.url = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SoftwareUpdate {
+    return {
+      url: isSet(object.url) ? String(object.url) : "",
+    };
+  },
+
+  toJSON(message: SoftwareUpdate): unknown {
+    const obj: any = {};
+    message.url !== undefined && (obj.url = message.url);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SoftwareUpdate>, I>>(
+    object: I
+  ): SoftwareUpdate {
+    const message = createBaseSoftwareUpdate();
+    message.url = object.url ?? "";
+    return message;
+  },
+};
+
+function createBaseFetchLocalAddr(): FetchLocalAddr {
+  return { socketAddr: new Uint8Array(), relayServer: "" };
+}
+
+export const FetchLocalAddr = {
+  encode(message: FetchLocalAddr, writer: Writer = Writer.create()): Writer {
+    if (message.socketAddr.length !== 0) {
+      writer.uint32(10).bytes(message.socketAddr);
+    }
+    if (message.relayServer !== "") {
+      writer.uint32(18).string(message.relayServer);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): FetchLocalAddr {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFetchLocalAddr();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.socketAddr = reader.bytes();
+          break;
+        case 2:
+          message.relayServer = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FetchLocalAddr {
+    return {
+      socketAddr: isSet(object.socketAddr)
+        ? bytesFromBase64(object.socketAddr)
+        : new Uint8Array(),
+      relayServer: isSet(object.relayServer) ? String(object.relayServer) : "",
+    };
+  },
+
+  toJSON(message: FetchLocalAddr): unknown {
+    const obj: any = {};
+    message.socketAddr !== undefined &&
+      (obj.socketAddr = base64FromBytes(
+        message.socketAddr !== undefined ? message.socketAddr : new Uint8Array()
+      ));
+    message.relayServer !== undefined &&
+      (obj.relayServer = message.relayServer);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FetchLocalAddr>, I>>(
+    object: I
+  ): FetchLocalAddr {
+    const message = createBaseFetchLocalAddr();
+    message.socketAddr = object.socketAddr ?? new Uint8Array();
+    message.relayServer = object.relayServer ?? "";
+    return message;
+  },
+};
+
+function createBaseLocalAddr(): LocalAddr {
+  return {
+    socketAddr: new Uint8Array(),
+    localAddr: new Uint8Array(),
+    relayServer: "",
+    id: "",
+    version: "",
+  };
+}
+
+export const LocalAddr = {
+  encode(message: LocalAddr, writer: Writer = Writer.create()): Writer {
+    if (message.socketAddr.length !== 0) {
+      writer.uint32(10).bytes(message.socketAddr);
+    }
+    if (message.localAddr.length !== 0) {
+      writer.uint32(18).bytes(message.localAddr);
+    }
+    if (message.relayServer !== "") {
+      writer.uint32(26).string(message.relayServer);
+    }
+    if (message.id !== "") {
+      writer.uint32(34).string(message.id);
+    }
+    if (message.version !== "") {
+      writer.uint32(42).string(message.version);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): LocalAddr {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLocalAddr();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.socketAddr = reader.bytes();
+          break;
+        case 2:
+          message.localAddr = reader.bytes();
+          break;
+        case 3:
+          message.relayServer = reader.string();
+          break;
+        case 4:
+          message.id = reader.string();
+          break;
+        case 5:
+          message.version = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): LocalAddr {
+    return {
+      socketAddr: isSet(object.socketAddr)
+        ? bytesFromBase64(object.socketAddr)
+        : new Uint8Array(),
+      localAddr: isSet(object.localAddr)
+        ? bytesFromBase64(object.localAddr)
+        : new Uint8Array(),
+      relayServer: isSet(object.relayServer) ? String(object.relayServer) : "",
+      id: isSet(object.id) ? String(object.id) : "",
+      version: isSet(object.version) ? String(object.version) : "",
+    };
+  },
+
+  toJSON(message: LocalAddr): unknown {
+    const obj: any = {};
+    message.socketAddr !== undefined &&
+      (obj.socketAddr = base64FromBytes(
+        message.socketAddr !== undefined ? message.socketAddr : new Uint8Array()
+      ));
+    message.localAddr !== undefined &&
+      (obj.localAddr = base64FromBytes(
+        message.localAddr !== undefined ? message.localAddr : new Uint8Array()
+      ));
+    message.relayServer !== undefined &&
+      (obj.relayServer = message.relayServer);
+    message.id !== undefined && (obj.id = message.id);
+    message.version !== undefined && (obj.version = message.version);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<LocalAddr>, I>>(
+    object: I
+  ): LocalAddr {
+    const message = createBaseLocalAddr();
+    message.socketAddr = object.socketAddr ?? new Uint8Array();
+    message.localAddr = object.localAddr ?? new Uint8Array();
+    message.relayServer = object.relayServer ?? "";
+    message.id = object.id ?? "";
+    message.version = object.version ?? "";
+    return message;
+  },
+};
+
+function createBasePeerDiscovery(): PeerDiscovery {
+  return {
+    cmd: "",
+    mac: "",
+    id: "",
+    username: "",
+    hostname: "",
+    platform: "",
+    misc: "",
+  };
+}
+
+export const PeerDiscovery = {
+  encode(message: PeerDiscovery, writer: Writer = Writer.create()): Writer {
+    if (message.cmd !== "") {
+      writer.uint32(10).string(message.cmd);
+    }
+    if (message.mac !== "") {
+      writer.uint32(18).string(message.mac);
+    }
+    if (message.id !== "") {
+      writer.uint32(26).string(message.id);
+    }
+    if (message.username !== "") {
+      writer.uint32(34).string(message.username);
+    }
+    if (message.hostname !== "") {
+      writer.uint32(42).string(message.hostname);
+    }
+    if (message.platform !== "") {
+      writer.uint32(50).string(message.platform);
+    }
+    if (message.misc !== "") {
+      writer.uint32(58).string(message.misc);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): PeerDiscovery {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePeerDiscovery();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.cmd = reader.string();
+          break;
+        case 2:
+          message.mac = reader.string();
+          break;
+        case 3:
+          message.id = reader.string();
+          break;
+        case 4:
+          message.username = reader.string();
+          break;
+        case 5:
+          message.hostname = reader.string();
+          break;
+        case 6:
+          message.platform = reader.string();
+          break;
+        case 7:
+          message.misc = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PeerDiscovery {
+    return {
+      cmd: isSet(object.cmd) ? String(object.cmd) : "",
+      mac: isSet(object.mac) ? String(object.mac) : "",
+      id: isSet(object.id) ? String(object.id) : "",
+      username: isSet(object.username) ? String(object.username) : "",
+      hostname: isSet(object.hostname) ? String(object.hostname) : "",
+      platform: isSet(object.platform) ? String(object.platform) : "",
+      misc: isSet(object.misc) ? String(object.misc) : "",
+    };
+  },
+
+  toJSON(message: PeerDiscovery): unknown {
+    const obj: any = {};
+    message.cmd !== undefined && (obj.cmd = message.cmd);
+    message.mac !== undefined && (obj.mac = message.mac);
+    message.id !== undefined && (obj.id = message.id);
+    message.username !== undefined && (obj.username = message.username);
+    message.hostname !== undefined && (obj.hostname = message.hostname);
+    message.platform !== undefined && (obj.platform = message.platform);
+    message.misc !== undefined && (obj.misc = message.misc);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PeerDiscovery>, I>>(
+    object: I
+  ): PeerDiscovery {
+    const message = createBasePeerDiscovery();
+    message.cmd = object.cmd ?? "";
+    message.mac = object.mac ?? "";
+    message.id = object.id ?? "";
+    message.username = object.username ?? "";
+    message.hostname = object.hostname ?? "";
+    message.platform = object.platform ?? "";
+    message.misc = object.misc ?? "";
+    return message;
+  },
+};
+
+function createBaseRendezvousMessage(): RendezvousMessage {
+  return {
+    registerPeer: undefined,
+    registerPeerResponse: undefined,
+    punchHoleRequest: undefined,
+    punchHole: undefined,
+    punchHoleSent: undefined,
+    punchHoleResponse: undefined,
+    fetchLocalAddr: undefined,
+    localAddr: undefined,
+    configureUpdate: undefined,
+    registerPk: undefined,
+    registerPkResponse: undefined,
+    softwareUpdate: undefined,
+    requestRelay: undefined,
+    relayResponse: undefined,
+    testNatRequest: undefined,
+    testNatResponse: undefined,
+    peerDiscovery: undefined,
+  };
+}
+
+export const RendezvousMessage = {
+  encode(message: RendezvousMessage, writer: Writer = Writer.create()): Writer {
+    if (message.registerPeer !== undefined) {
+      RegisterPeer.encode(
+        message.registerPeer,
+        writer.uint32(50).fork()
+      ).ldelim();
+    }
+    if (message.registerPeerResponse !== undefined) {
+      RegisterPeerResponse.encode(
+        message.registerPeerResponse,
+        writer.uint32(58).fork()
+      ).ldelim();
+    }
+    if (message.punchHoleRequest !== undefined) {
+      PunchHoleRequest.encode(
+        message.punchHoleRequest,
+        writer.uint32(66).fork()
+      ).ldelim();
+    }
+    if (message.punchHole !== undefined) {
+      PunchHole.encode(message.punchHole, writer.uint32(74).fork()).ldelim();
+    }
+    if (message.punchHoleSent !== undefined) {
+      PunchHoleSent.encode(
+        message.punchHoleSent,
+        writer.uint32(82).fork()
+      ).ldelim();
+    }
+    if (message.punchHoleResponse !== undefined) {
+      PunchHoleResponse.encode(
+        message.punchHoleResponse,
+        writer.uint32(90).fork()
+      ).ldelim();
+    }
+    if (message.fetchLocalAddr !== undefined) {
+      FetchLocalAddr.encode(
+        message.fetchLocalAddr,
+        writer.uint32(98).fork()
+      ).ldelim();
+    }
+    if (message.localAddr !== undefined) {
+      LocalAddr.encode(message.localAddr, writer.uint32(106).fork()).ldelim();
+    }
+    if (message.configureUpdate !== undefined) {
+      ConfigUpdate.encode(
+        message.configureUpdate,
+        writer.uint32(114).fork()
+      ).ldelim();
+    }
+    if (message.registerPk !== undefined) {
+      RegisterPk.encode(message.registerPk, writer.uint32(122).fork()).ldelim();
+    }
+    if (message.registerPkResponse !== undefined) {
+      RegisterPkResponse.encode(
+        message.registerPkResponse,
+        writer.uint32(130).fork()
+      ).ldelim();
+    }
+    if (message.softwareUpdate !== undefined) {
+      SoftwareUpdate.encode(
+        message.softwareUpdate,
+        writer.uint32(138).fork()
+      ).ldelim();
+    }
+    if (message.requestRelay !== undefined) {
+      RequestRelay.encode(
+        message.requestRelay,
+        writer.uint32(146).fork()
+      ).ldelim();
+    }
+    if (message.relayResponse !== undefined) {
+      RelayResponse.encode(
+        message.relayResponse,
+        writer.uint32(154).fork()
+      ).ldelim();
+    }
+    if (message.testNatRequest !== undefined) {
+      TestNatRequest.encode(
+        message.testNatRequest,
+        writer.uint32(162).fork()
+      ).ldelim();
+    }
+    if (message.testNatResponse !== undefined) {
+      TestNatResponse.encode(
+        message.testNatResponse,
+        writer.uint32(170).fork()
+      ).ldelim();
+    }
+    if (message.peerDiscovery !== undefined) {
+      PeerDiscovery.encode(
+        message.peerDiscovery,
+        writer.uint32(178).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): RendezvousMessage {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRendezvousMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 6:
+          message.registerPeer = RegisterPeer.decode(reader, reader.uint32());
+          break;
+        case 7:
+          message.registerPeerResponse = RegisterPeerResponse.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 8:
+          message.punchHoleRequest = PunchHoleRequest.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 9:
+          message.punchHole = PunchHole.decode(reader, reader.uint32());
+          break;
+        case 10:
+          message.punchHoleSent = PunchHoleSent.decode(reader, reader.uint32());
+          break;
+        case 11:
+          message.punchHoleResponse = PunchHoleResponse.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 12:
+          message.fetchLocalAddr = FetchLocalAddr.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 13:
+          message.localAddr = LocalAddr.decode(reader, reader.uint32());
+          break;
+        case 14:
+          message.configureUpdate = ConfigUpdate.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 15:
+          message.registerPk = RegisterPk.decode(reader, reader.uint32());
+          break;
+        case 16:
+          message.registerPkResponse = RegisterPkResponse.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 17:
+          message.softwareUpdate = SoftwareUpdate.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 18:
+          message.requestRelay = RequestRelay.decode(reader, reader.uint32());
+          break;
+        case 19:
+          message.relayResponse = RelayResponse.decode(reader, reader.uint32());
+          break;
+        case 20:
+          message.testNatRequest = TestNatRequest.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 21:
+          message.testNatResponse = TestNatResponse.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 22:
+          message.peerDiscovery = PeerDiscovery.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RendezvousMessage {
+    return {
+      registerPeer: isSet(object.registerPeer)
+        ? RegisterPeer.fromJSON(object.registerPeer)
+        : undefined,
+      registerPeerResponse: isSet(object.registerPeerResponse)
+        ? RegisterPeerResponse.fromJSON(object.registerPeerResponse)
+        : undefined,
+      punchHoleRequest: isSet(object.punchHoleRequest)
+        ? PunchHoleRequest.fromJSON(object.punchHoleRequest)
+        : undefined,
+      punchHole: isSet(object.punchHole)
+        ? PunchHole.fromJSON(object.punchHole)
+        : undefined,
+      punchHoleSent: isSet(object.punchHoleSent)
+        ? PunchHoleSent.fromJSON(object.punchHoleSent)
+        : undefined,
+      punchHoleResponse: isSet(object.punchHoleResponse)
+        ? PunchHoleResponse.fromJSON(object.punchHoleResponse)
+        : undefined,
+      fetchLocalAddr: isSet(object.fetchLocalAddr)
+        ? FetchLocalAddr.fromJSON(object.fetchLocalAddr)
+        : undefined,
+      localAddr: isSet(object.localAddr)
+        ? LocalAddr.fromJSON(object.localAddr)
+        : undefined,
+      configureUpdate: isSet(object.configureUpdate)
+        ? ConfigUpdate.fromJSON(object.configureUpdate)
+        : undefined,
+      registerPk: isSet(object.registerPk)
+        ? RegisterPk.fromJSON(object.registerPk)
+        : undefined,
+      registerPkResponse: isSet(object.registerPkResponse)
+        ? RegisterPkResponse.fromJSON(object.registerPkResponse)
+        : undefined,
+      softwareUpdate: isSet(object.softwareUpdate)
+        ? SoftwareUpdate.fromJSON(object.softwareUpdate)
+        : undefined,
+      requestRelay: isSet(object.requestRelay)
+        ? RequestRelay.fromJSON(object.requestRelay)
+        : undefined,
+      relayResponse: isSet(object.relayResponse)
+        ? RelayResponse.fromJSON(object.relayResponse)
+        : undefined,
+      testNatRequest: isSet(object.testNatRequest)
+        ? TestNatRequest.fromJSON(object.testNatRequest)
+        : undefined,
+      testNatResponse: isSet(object.testNatResponse)
+        ? TestNatResponse.fromJSON(object.testNatResponse)
+        : undefined,
+      peerDiscovery: isSet(object.peerDiscovery)
+        ? PeerDiscovery.fromJSON(object.peerDiscovery)
+        : undefined,
+    };
+  },
+
+  toJSON(message: RendezvousMessage): unknown {
+    const obj: any = {};
+    message.registerPeer !== undefined &&
+      (obj.registerPeer = message.registerPeer
+        ? RegisterPeer.toJSON(message.registerPeer)
+        : undefined);
+    message.registerPeerResponse !== undefined &&
+      (obj.registerPeerResponse = message.registerPeerResponse
+        ? RegisterPeerResponse.toJSON(message.registerPeerResponse)
+        : undefined);
+    message.punchHoleRequest !== undefined &&
+      (obj.punchHoleRequest = message.punchHoleRequest
+        ? PunchHoleRequest.toJSON(message.punchHoleRequest)
+        : undefined);
+    message.punchHole !== undefined &&
+      (obj.punchHole = message.punchHole
+        ? PunchHole.toJSON(message.punchHole)
+        : undefined);
+    message.punchHoleSent !== undefined &&
+      (obj.punchHoleSent = message.punchHoleSent
+        ? PunchHoleSent.toJSON(message.punchHoleSent)
+        : undefined);
+    message.punchHoleResponse !== undefined &&
+      (obj.punchHoleResponse = message.punchHoleResponse
+        ? PunchHoleResponse.toJSON(message.punchHoleResponse)
+        : undefined);
+    message.fetchLocalAddr !== undefined &&
+      (obj.fetchLocalAddr = message.fetchLocalAddr
+        ? FetchLocalAddr.toJSON(message.fetchLocalAddr)
+        : undefined);
+    message.localAddr !== undefined &&
+      (obj.localAddr = message.localAddr
+        ? LocalAddr.toJSON(message.localAddr)
+        : undefined);
+    message.configureUpdate !== undefined &&
+      (obj.configureUpdate = message.configureUpdate
+        ? ConfigUpdate.toJSON(message.configureUpdate)
+        : undefined);
+    message.registerPk !== undefined &&
+      (obj.registerPk = message.registerPk
+        ? RegisterPk.toJSON(message.registerPk)
+        : undefined);
+    message.registerPkResponse !== undefined &&
+      (obj.registerPkResponse = message.registerPkResponse
+        ? RegisterPkResponse.toJSON(message.registerPkResponse)
+        : undefined);
+    message.softwareUpdate !== undefined &&
+      (obj.softwareUpdate = message.softwareUpdate
+        ? SoftwareUpdate.toJSON(message.softwareUpdate)
+        : undefined);
+    message.requestRelay !== undefined &&
+      (obj.requestRelay = message.requestRelay
+        ? RequestRelay.toJSON(message.requestRelay)
+        : undefined);
+    message.relayResponse !== undefined &&
+      (obj.relayResponse = message.relayResponse
+        ? RelayResponse.toJSON(message.relayResponse)
+        : undefined);
+    message.testNatRequest !== undefined &&
+      (obj.testNatRequest = message.testNatRequest
+        ? TestNatRequest.toJSON(message.testNatRequest)
+        : undefined);
+    message.testNatResponse !== undefined &&
+      (obj.testNatResponse = message.testNatResponse
+        ? TestNatResponse.toJSON(message.testNatResponse)
+        : undefined);
+    message.peerDiscovery !== undefined &&
+      (obj.peerDiscovery = message.peerDiscovery
+        ? PeerDiscovery.toJSON(message.peerDiscovery)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<RendezvousMessage>, I>>(
+    object: I
+  ): RendezvousMessage {
+    const message = createBaseRendezvousMessage();
+    message.registerPeer =
+      object.registerPeer !== undefined && object.registerPeer !== null
+        ? RegisterPeer.fromPartial(object.registerPeer)
+        : undefined;
+    message.registerPeerResponse =
+      object.registerPeerResponse !== undefined &&
+      object.registerPeerResponse !== null
+        ? RegisterPeerResponse.fromPartial(object.registerPeerResponse)
+        : undefined;
+    message.punchHoleRequest =
+      object.punchHoleRequest !== undefined && object.punchHoleRequest !== null
+        ? PunchHoleRequest.fromPartial(object.punchHoleRequest)
+        : undefined;
+    message.punchHole =
+      object.punchHole !== undefined && object.punchHole !== null
+        ? PunchHole.fromPartial(object.punchHole)
+        : undefined;
+    message.punchHoleSent =
+      object.punchHoleSent !== undefined && object.punchHoleSent !== null
+        ? PunchHoleSent.fromPartial(object.punchHoleSent)
+        : undefined;
+    message.punchHoleResponse =
+      object.punchHoleResponse !== undefined &&
+      object.punchHoleResponse !== null
+        ? PunchHoleResponse.fromPartial(object.punchHoleResponse)
+        : undefined;
+    message.fetchLocalAddr =
+      object.fetchLocalAddr !== undefined && object.fetchLocalAddr !== null
+        ? FetchLocalAddr.fromPartial(object.fetchLocalAddr)
+        : undefined;
+    message.localAddr =
+      object.localAddr !== undefined && object.localAddr !== null
+        ? LocalAddr.fromPartial(object.localAddr)
+        : undefined;
+    message.configureUpdate =
+      object.configureUpdate !== undefined && object.configureUpdate !== null
+        ? ConfigUpdate.fromPartial(object.configureUpdate)
+        : undefined;
+    message.registerPk =
+      object.registerPk !== undefined && object.registerPk !== null
+        ? RegisterPk.fromPartial(object.registerPk)
+        : undefined;
+    message.registerPkResponse =
+      object.registerPkResponse !== undefined &&
+      object.registerPkResponse !== null
+        ? RegisterPkResponse.fromPartial(object.registerPkResponse)
+        : undefined;
+    message.softwareUpdate =
+      object.softwareUpdate !== undefined && object.softwareUpdate !== null
+        ? SoftwareUpdate.fromPartial(object.softwareUpdate)
+        : undefined;
+    message.requestRelay =
+      object.requestRelay !== undefined && object.requestRelay !== null
+        ? RequestRelay.fromPartial(object.requestRelay)
+        : undefined;
+    message.relayResponse =
+      object.relayResponse !== undefined && object.relayResponse !== null
+        ? RelayResponse.fromPartial(object.relayResponse)
+        : undefined;
+    message.testNatRequest =
+      object.testNatRequest !== undefined && object.testNatRequest !== null
+        ? TestNatRequest.fromPartial(object.testNatRequest)
+        : undefined;
+    message.testNatResponse =
+      object.testNatResponse !== undefined && object.testNatResponse !== null
+        ? TestNatResponse.fromPartial(object.testNatResponse)
+        : undefined;
+    message.peerDiscovery =
+      object.peerDiscovery !== undefined && object.peerDiscovery !== null
+        ? PeerDiscovery.fromPartial(object.peerDiscovery)
+        : undefined;
+    return message;
+  },
+};
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof self !== "undefined") return self;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+  throw "Unable to locate global object";
+})();
+
+const atob: (b64: string) => string =
+  globalThis.atob ||
+  ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
+function bytesFromBase64(b64: string): Uint8Array {
+  const bin = atob(b64);
+  const arr = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; ++i) {
+    arr[i] = bin.charCodeAt(i);
+  }
+  return arr;
+}
+
+const btoa: (bin: string) => string =
+  globalThis.btoa ||
+  ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
+function base64FromBytes(arr: Uint8Array): string {
+  const bin: string[] = [];
+  for (const byte of arr) {
+    bin.push(String.fromCharCode(byte));
+  }
+  return btoa(bin.join(""));
+}
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
+        Exclude<keyof I, KeysOfUnion<P>>,
+        never
+      >;
+
+// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
+// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
+if (util.Long !== Long) {
+  util.Long = Long as any;
+  configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
diff --git a/ts_proto.py b/ts_proto.py
new file mode 100644
index 000000000..d1627f51f
--- /dev/null
+++ b/ts_proto.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+import os
+
+path = os.path.abspath(os.path.join(os.getcwd(), '..', 'hbb', 'libs', 'hbb_common', 'protos'))
+
+if os.name == 'nt':
+    cmd = r'protoc --plugin=protoc-gen-ts_proto=.\node_modules\.bin\protoc-gen-ts_proto.cmd  -I "%s" --ts_proto_out=./src/ rendezvous.proto'%path
+    print(cmd)
+    os.system(cmd)
+    cmd = r'protoc --plugin=protoc-gen-ts_proto=.\node_modules\.bin\protoc-gen-ts_proto.cmd  -I "%s" --ts_proto_out=./src/ message.proto'%path
+    print(cmd)
+    os.system(cmd)
+else:
+    cmd = r'protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto -I "%s" --ts_proto_out=./src/ rendezvous.proto'%path
+    print(cmd)
+    os.system(cmd)
+    cmd = r'protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto -I "%s" --ts_proto_out=./src/ message.proto'%path
+    print(cmd)
+    os.system(cmd)
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index 2cfb703a5..8672df468 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,6 +2,79 @@
 # yarn lockfile v1
 
 
+"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf"
+  integrity sha1-m4sMxmPWaafY9vXQiToU00jzD78=
+
+"@protobufjs/base64@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735"
+  integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==
+
+"@protobufjs/codegen@^2.0.4":
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb"
+  integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==
+
+"@protobufjs/eventemitter@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70"
+  integrity sha1-NVy8mLr61ZePntCV85diHx0Ga3A=
+
+"@protobufjs/fetch@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45"
+  integrity sha1-upn7WYYUr2VwDBYZ/wbUVLDYTEU=
+  dependencies:
+    "@protobufjs/aspromise" "^1.1.1"
+    "@protobufjs/inquire" "^1.1.0"
+
+"@protobufjs/float@^1.0.2":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1"
+  integrity sha1-Xp4avctz/Ap8uLKR33jIy9l7h9E=
+
+"@protobufjs/inquire@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089"
+  integrity sha1-/yAOPnzyQp4tyvwRQIKOjMY48Ik=
+
+"@protobufjs/path@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d"
+  integrity sha1-bMKyDFya1q0NzP0hynZz2Nf79o0=
+
+"@protobufjs/pool@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54"
+  integrity sha1-Cf0V8tbTq/qbZbw2ZQbWrXhG/1Q=
+
+"@protobufjs/utf8@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570"
+  integrity sha1-p3c2C1s5oaLlEG+OhY8v0tBgxXA=
+
+"@types/long@^4.0.1":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.1.tgz#459c65fa1867dafe6a8f322c4c51695663cc55e9"
+  integrity sha512-5tXH6Bx/kNGd3MgffdmP4dy2Z+G4eaXw0SE81Tq3BNadtnMR5/ySMzX4SLEzHJzSmPNn4HIdpQsBvXMUykr58w==
+
+"@types/node@>=13.7.0":
+  version "17.0.8"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.8.tgz#50d680c8a8a78fe30abe6906453b21ad8ab0ad7b"
+  integrity sha512-YofkM6fGv4gDJq78g4j0mMuGMkZVxZDgtU0JRdx6FgiJDG+0fY0GKVolOV8WqVmEhLCXkQRjwDdKyPxJp/uucg==
+
+"@types/object-hash@^1.3.0":
+  version "1.3.4"
+  resolved "https://registry.yarnpkg.com/@types/object-hash/-/object-hash-1.3.4.tgz#079ba142be65833293673254831b5e3e847fe58b"
+  integrity sha512-xFdpkAkikBgqBdG9vIlsqffDV8GpvnPEzs0IUtr1v3BEB97ijsFQ4RXVbUZwjFThhB4MDSTUfvmxUD5PGx0wXA==
+
+dataloader@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/dataloader/-/dataloader-1.4.0.tgz#bca11d867f5d3f1b9ed9f737bd15970c65dff5c8"
+  integrity sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw==
+
 esbuild-android-arm64@0.13.15:
   version "0.13.15"
   resolved "https://registry.yarnpkg.com/esbuild-android-arm64/-/esbuild-android-arm64-0.13.15.tgz#3fc3ff0bab76fe35dd237476b5d2b32bb20a3d44"
@@ -134,11 +207,26 @@ is-core-module@^2.8.0:
   dependencies:
     has "^1.0.3"
 
+lodash@^4.17.15:
+  version "4.17.21"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
+  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
+
+long@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/long/-/long-4.0.0.tgz#9a7b71cfb7d361a194ea555241c92f7468d5bf28"
+  integrity sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==
+
 nanoid@^3.1.30:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.2.0.tgz#62667522da6673971cca916a6d3eff3f415ff80c"
   integrity sha512-fmsZYa9lpn69Ad5eDn7FMcnnSR+8R34W9qJEijxYhTbfOWzr22n1QxCMzXLK+ODyW2973V3Fux959iQoUxzUIA==
 
+object-hash@^1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/object-hash/-/object-hash-1.3.1.tgz#fde452098a951cb145f039bb7d455449ddc126df"
+  integrity sha512-OSuu/pU4ENM9kmREg0BdNrUDIl1heYa4mBZacJc+vVWz4GtAwu7jO8s4AIt2aGRUTqxykpWzI3Oqnsm13tTMDA==
+
 path-parse@^1.0.7:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
@@ -158,6 +246,30 @@ postcss@^8.4.5:
     picocolors "^1.0.0"
     source-map-js "^1.0.1"
 
+prettier@^2.5.1:
+  version "2.5.1"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.5.1.tgz#fff75fa9d519c54cf0fce328c1017d94546bc56a"
+  integrity sha512-vBZcPRUR5MZJwoyi3ZoyQlc1rXeEck8KgeC9AwwOn+exuxLxq5toTRDTSaVrXHxelDMHy9zlicw8u66yxoSUFg==
+
+protobufjs@^6.8.8:
+  version "6.11.2"
+  resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-6.11.2.tgz#de39fabd4ed32beaa08e9bb1e30d08544c1edf8b"
+  integrity sha512-4BQJoPooKJl2G9j3XftkIXjoC9C0Av2NOrWmbLWT1vH32GcSUHjM0Arra6UfTsVyfMAuFzaLucXn1sadxJydAw==
+  dependencies:
+    "@protobufjs/aspromise" "^1.1.2"
+    "@protobufjs/base64" "^1.1.2"
+    "@protobufjs/codegen" "^2.0.4"
+    "@protobufjs/eventemitter" "^1.1.0"
+    "@protobufjs/fetch" "^1.1.0"
+    "@protobufjs/float" "^1.0.2"
+    "@protobufjs/inquire" "^1.1.0"
+    "@protobufjs/path" "^1.1.2"
+    "@protobufjs/pool" "^1.1.0"
+    "@protobufjs/utf8" "^1.1.0"
+    "@types/long" "^4.0.1"
+    "@types/node" ">=13.7.0"
+    long "^4.0.0"
+
 resolve@^1.20.0:
   version "1.21.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.21.0.tgz#b51adc97f3472e6a5cf4444d34bc9d6b9037591f"
@@ -184,6 +296,34 @@ supports-preserve-symlinks-flag@^1.0.0:
   resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
+ts-poet@^4.5.0:
+  version "4.10.0"
+  resolved "https://registry.yarnpkg.com/ts-poet/-/ts-poet-4.10.0.tgz#8732374655e87f8f833e5d110938e346713e8c66"
+  integrity sha512-V5xzt+LDMVtxWvK12WVwHhGHTA//CeoPdWOqka0mMjlRqq7RPKYSfWEnzJdMmhNbd34BwZuZpip4mm+nqEcbQA==
+  dependencies:
+    lodash "^4.17.15"
+    prettier "^2.5.1"
+
+ts-proto-descriptors@^1.2.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/ts-proto-descriptors/-/ts-proto-descriptors-1.3.1.tgz#760ebaaa19475b03662f7b358ffea45b9c5348f5"
+  integrity sha512-Cybb3fqceMwA6JzHdC32dIo8eVGVmXrM6TWhdk1XQVVHT/6OQqk0ioyX1dIdu3rCIBhRmWUhUE4HsyK+olmgMw==
+  dependencies:
+    long "^4.0.0"
+    protobufjs "^6.8.8"
+
+ts-proto@^1.101.0:
+  version "1.101.0"
+  resolved "https://registry.yarnpkg.com/ts-proto/-/ts-proto-1.101.0.tgz#f8ce4523a0cb32ff224ff8a5759c2c046bf96244"
+  integrity sha512-XUV0WKQ3icHMToOOpUjf0RCKF9md+Lu9TV00LQlZ6ailJhbBqLh0BXQJ1PFUGxEW8YV65Wc/N8vAir152OE2Sg==
+  dependencies:
+    "@types/object-hash" "^1.3.0"
+    dataloader "^1.4.0"
+    object-hash "^1.3.1"
+    protobufjs "^6.8.8"
+    ts-poet "^4.5.0"
+    ts-proto-descriptors "^1.2.1"
+
 typescript@^4.4.4:
   version "4.5.4"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.5.4.tgz#a17d3a0263bf5c8723b9c52f43c5084edf13c2e8"