// PV version = 9a65ffd093eefcad972f715896bf35d9d5058a2d

// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file pianoverse.proto (package pianoverse, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";

/**
 * @generated from enum pianoverse.Role
 */
export enum Role {
  /**
   * @generated from enum value: USER = 0;
   */
  USER = 0,

  /**
   * @generated from enum value: MODERATOR = 1;
   */
  MODERATOR = 1,

  /**
   * @generated from enum value: DEVELOPER = 2;
   */
  DEVELOPER = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(Role)
proto3.util.setEnumType(Role, "pianoverse.Role", [
  { no: 0, name: "USER" },
  { no: 1, name: "MODERATOR" },
  { no: 2, name: "DEVELOPER" },
]);

/**
 * @generated from message pianoverse.ClientMessage
 */
export class ClientMessage extends Message<ClientMessage> {
  /**
   * @generated from field: string chown = 1;
   */
  chown = "";

  /**
   * @generated from field: pianoverse.ClientMessage.EventType event = 2;
   */
  event = ClientMessage_EventType.CHOWN;

  /**
   * @generated from field: pianoverse.ClientMessage.Heartbeat ping = 3;
   */
  ping?: ClientMessage_Heartbeat;

  /**
   * @generated from field: pianoverse.ClientMessage.Room room = 4;
   */
  room?: ClientMessage_Room;

  /**
   * @generated from field: pianoverse.Profile profile = 5;
   */
  profile?: Profile;

  /**
   * @generated from field: string chat = 6;
   */
  chat = "";

  /**
   * @generated from field: pianoverse.Move move = 7;
   */
  move?: Move;

  /**
   * @generated from field: string mute = 8;
   */
  mute = "";

  /**
   * @generated from field: string unmute = 9;
   */
  unmute = "";

  /**
   * @generated from field: string kick = 10;
   */
  kick = "";

  /**
   * @generated from field: pianoverse.Press press = 11;
   */
  press?: Press;

  /**
   * @generated from field: pianoverse.Release release = 12;
   */
  release?: Release;

  /**
   * @generated from field: bool sustain = 13;
   */
  sustain = false;

  /**
   * @generated from field: pianoverse.ClientMessage.Heartbeat heartbeat = 14;
   */
  heartbeat?: ClientMessage_Heartbeat;

  /**
   * @generated from field: pianoverse.ClientMessage.Ban ban = 15;
   */
  ban?: ClientMessage_Ban;

  /**
   * @generated from field: string ipban = 16;
   */
  ipban = "";

  /**
   * @generated from field: string mod = 17;
   */
  mod = "";

  /**
   * @generated from field: string unmod = 18;
   */
  unmod = "";

  constructor(data?: PartialMessage<ClientMessage>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ClientMessage";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "chown", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "event", kind: "enum", T: proto3.getEnumType(ClientMessage_EventType) },
    { no: 3, name: "ping", kind: "message", T: ClientMessage_Heartbeat },
    { no: 4, name: "room", kind: "message", T: ClientMessage_Room },
    { no: 5, name: "profile", kind: "message", T: Profile },
    { no: 6, name: "chat", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "move", kind: "message", T: Move },
    { no: 8, name: "mute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 9, name: "unmute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "kick", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 11, name: "press", kind: "message", T: Press },
    { no: 12, name: "release", kind: "message", T: Release },
    { no: 13, name: "sustain", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 14, name: "heartbeat", kind: "message", T: ClientMessage_Heartbeat },
    { no: 15, name: "ban", kind: "message", T: ClientMessage_Ban },
    { no: 16, name: "ipban", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 17, name: "mod", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 18, name: "unmod", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientMessage {
    return new ClientMessage().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientMessage {
    return new ClientMessage().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientMessage {
    return new ClientMessage().fromJsonString(jsonString, options);
  }

  static equals(a: ClientMessage | PlainMessage<ClientMessage> | undefined, b: ClientMessage | PlainMessage<ClientMessage> | undefined): boolean {
    return proto3.util.equals(ClientMessage, a, b);
  }
}

/**
 * @generated from enum pianoverse.ClientMessage.EventType
 */
export enum ClientMessage_EventType {
  /**
   * @generated from enum value: CHOWN = 0;
   */
  CHOWN = 0,

  /**
   * @generated from enum value: PING = 1;
   */
  PING = 1,

  /**
   * @generated from enum value: ROOM = 2;
   */
  ROOM = 2,

  /**
   * @generated from enum value: PROFILE = 3;
   */
  PROFILE = 3,

  /**
   * @generated from enum value: CHAT = 4;
   */
  CHAT = 4,

  /**
   * @generated from enum value: MOVE = 5;
   */
  MOVE = 5,

  /**
   * @generated from enum value: MUTE = 6;
   */
  MUTE = 6,

  /**
   * @generated from enum value: UNMUTE = 7;
   */
  UNMUTE = 7,

  /**
   * @generated from enum value: KICK = 8;
   */
  KICK = 8,

  /**
   * @generated from enum value: PRESS = 9;
   */
  PRESS = 9,

  /**
   * @generated from enum value: RELEASE = 10;
   */
  RELEASE = 10,

  /**
   * @generated from enum value: SUSTAIN = 11;
   */
  SUSTAIN = 11,

  /**
   * @generated from enum value: HEARTBEAT = 12;
   */
  HEARTBEAT = 12,

  /**
   * @generated from enum value: BAN = 13;
   */
  BAN = 13,

  /**
   * @generated from enum value: IPBAN = 14;
   */
  IPBAN = 14,

  /**
   * @generated from enum value: MOD = 15;
   */
  MOD = 15,

  /**
   * @generated from enum value: UNMOD = 16;
   */
  UNMOD = 16,
}
// Retrieve enum metadata with: proto3.getEnumType(ClientMessage_EventType)
proto3.util.setEnumType(ClientMessage_EventType, "pianoverse.ClientMessage.EventType", [
  { no: 0, name: "CHOWN" },
  { no: 1, name: "PING" },
  { no: 2, name: "ROOM" },
  { no: 3, name: "PROFILE" },
  { no: 4, name: "CHAT" },
  { no: 5, name: "MOVE" },
  { no: 6, name: "MUTE" },
  { no: 7, name: "UNMUTE" },
  { no: 8, name: "KICK" },
  { no: 9, name: "PRESS" },
  { no: 10, name: "RELEASE" },
  { no: 11, name: "SUSTAIN" },
  { no: 12, name: "HEARTBEAT" },
  { no: 13, name: "BAN" },
  { no: 14, name: "IPBAN" },
  { no: 15, name: "MOD" },
  { no: 16, name: "UNMOD" },
]);

/**
 * @generated from message pianoverse.ClientMessage.Room
 */
export class ClientMessage_Room extends Message<ClientMessage_Room> {
  /**
   * @generated from field: string room = 1;
   */
  room = "";

  /**
   * @generated from field: bool private = 2;
   */
  private = false;

  constructor(data?: PartialMessage<ClientMessage_Room>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ClientMessage.Room";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "private", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientMessage_Room {
    return new ClientMessage_Room().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientMessage_Room {
    return new ClientMessage_Room().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientMessage_Room {
    return new ClientMessage_Room().fromJsonString(jsonString, options);
  }

  static equals(a: ClientMessage_Room | PlainMessage<ClientMessage_Room> | undefined, b: ClientMessage_Room | PlainMessage<ClientMessage_Room> | undefined): boolean {
    return proto3.util.equals(ClientMessage_Room, a, b);
  }
}

/**
 * @generated from message pianoverse.ClientMessage.Heartbeat
 */
export class ClientMessage_Heartbeat extends Message<ClientMessage_Heartbeat> {
  constructor(data?: PartialMessage<ClientMessage_Heartbeat>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ClientMessage.Heartbeat";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientMessage_Heartbeat {
    return new ClientMessage_Heartbeat().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientMessage_Heartbeat {
    return new ClientMessage_Heartbeat().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientMessage_Heartbeat {
    return new ClientMessage_Heartbeat().fromJsonString(jsonString, options);
  }

  static equals(a: ClientMessage_Heartbeat | PlainMessage<ClientMessage_Heartbeat> | undefined, b: ClientMessage_Heartbeat | PlainMessage<ClientMessage_Heartbeat> | undefined): boolean {
    return proto3.util.equals(ClientMessage_Heartbeat, a, b);
  }
}

/**
 * @generated from message pianoverse.ClientMessage.Ban
 */
export class ClientMessage_Ban extends Message<ClientMessage_Ban> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: uint32 minutes = 2;
   */
  minutes = 0;

  constructor(data?: PartialMessage<ClientMessage_Ban>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ClientMessage.Ban";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "minutes", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientMessage_Ban {
    return new ClientMessage_Ban().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientMessage_Ban {
    return new ClientMessage_Ban().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientMessage_Ban {
    return new ClientMessage_Ban().fromJsonString(jsonString, options);
  }

  static equals(a: ClientMessage_Ban | PlainMessage<ClientMessage_Ban> | undefined, b: ClientMessage_Ban | PlainMessage<ClientMessage_Ban> | undefined): boolean {
    return proto3.util.equals(ClientMessage_Ban, a, b);
  }
}

/**
 * @generated from message pianoverse.ServerMessage
 */
export class ServerMessage extends Message<ServerMessage> {
  /**
   * @generated from field: pianoverse.Profile clear = 1;
   */
  clear?: Profile;

  /**
   * @generated from field: pianoverse.ServerMessage.EventType event = 2;
   */
  event = ServerMessage_EventType.CLEAR;

  /**
   * @generated from field: pianoverse.Profile pong = 3;
   */
  pong?: Profile;

  /**
   * @generated from field: pianoverse.ServerMessage.Chat chat = 4;
   */
  chat?: ServerMessage_Chat;

  /**
   * @generated from field: repeated pianoverse.ServerMessage.Room rooms = 5;
   */
  rooms: ServerMessage_Room[] = [];

  /**
   * @generated from field: pianoverse.ServerMessage.Welcome welcome = 6;
   */
  welcome?: ServerMessage_Welcome;

  /**
   * @generated from field: pianoverse.Move move = 7;
   */
  move?: Move;

  /**
   * @generated from field: pianoverse.Press press = 8;
   */
  press?: Press;

  /**
   * @generated from field: pianoverse.Release release = 9;
   */
  release?: Release;

  /**
   * @generated from field: pianoverse.ServerMessage.Sustain sustain = 10;
   */
  sustain?: ServerMessage_Sustain;

  /**
   * @generated from field: pianoverse.Profile profile = 11;
   */
  profile?: Profile;

  /**
   * @generated from field: pianoverse.Profile join = 12;
   */
  join?: Profile;

  /**
   * @generated from field: string leave = 13;
   */
  leave = "";

  /**
   * @generated from field: uint32 ratelimit = 14;
   */
  ratelimit = 0;

  /**
   * @generated from field: string message = 15;
   */
  message = "";

  /**
   * @generated from field: string chown = 16;
   */
  chown = "";

  constructor(data?: PartialMessage<ServerMessage>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ServerMessage";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "clear", kind: "message", T: Profile },
    { no: 2, name: "event", kind: "enum", T: proto3.getEnumType(ServerMessage_EventType) },
    { no: 3, name: "pong", kind: "message", T: Profile },
    { no: 4, name: "chat", kind: "message", T: ServerMessage_Chat },
    { no: 5, name: "rooms", kind: "message", T: ServerMessage_Room, repeated: true },
    { no: 6, name: "welcome", kind: "message", T: ServerMessage_Welcome },
    { no: 7, name: "move", kind: "message", T: Move },
    { no: 8, name: "press", kind: "message", T: Press },
    { no: 9, name: "release", kind: "message", T: Release },
    { no: 10, name: "sustain", kind: "message", T: ServerMessage_Sustain },
    { no: 11, name: "profile", kind: "message", T: Profile },
    { no: 12, name: "join", kind: "message", T: Profile },
    { no: 13, name: "leave", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 14, name: "ratelimit", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 15, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 16, name: "chown", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServerMessage {
    return new ServerMessage().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServerMessage {
    return new ServerMessage().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServerMessage {
    return new ServerMessage().fromJsonString(jsonString, options);
  }

  static equals(a: ServerMessage | PlainMessage<ServerMessage> | undefined, b: ServerMessage | PlainMessage<ServerMessage> | undefined): boolean {
    return proto3.util.equals(ServerMessage, a, b);
  }
}

/**
 * @generated from enum pianoverse.ServerMessage.EventType
 */
export enum ServerMessage_EventType {
  /**
   * @generated from enum value: CLEAR = 0;
   */
  CLEAR = 0,

  /**
   * @generated from enum value: PONG = 1;
   */
  PONG = 1,

  /**
   * @generated from enum value: CHAT = 2;
   */
  CHAT = 2,

  /**
   * @generated from enum value: ROOMS = 3;
   */
  ROOMS = 3,

  /**
   * @generated from enum value: WELCOME = 4;
   */
  WELCOME = 4,

  /**
   * @generated from enum value: MOVE = 5;
   */
  MOVE = 5,

  /**
   * @generated from enum value: PRESS = 6;
   */
  PRESS = 6,

  /**
   * @generated from enum value: RELEASE = 7;
   */
  RELEASE = 7,

  /**
   * @generated from enum value: SUSTAIN = 8;
   */
  SUSTAIN = 8,

  /**
   * @generated from enum value: PROFILE = 9;
   */
  PROFILE = 9,

  /**
   * @generated from enum value: JOIN = 10;
   */
  JOIN = 10,

  /**
   * @generated from enum value: LEAVE = 11;
   */
  LEAVE = 11,

  /**
   * @generated from enum value: RATELIMIT = 12;
   */
  RATELIMIT = 12,

  /**
   * @generated from enum value: MESSAGE = 13;
   */
  MESSAGE = 13,

  /**
   * @generated from enum value: CHOWN = 14;
   */
  CHOWN = 14,
}
// Retrieve enum metadata with: proto3.getEnumType(ServerMessage_EventType)
proto3.util.setEnumType(ServerMessage_EventType, "pianoverse.ServerMessage.EventType", [
  { no: 0, name: "CLEAR" },
  { no: 1, name: "PONG" },
  { no: 2, name: "CHAT" },
  { no: 3, name: "ROOMS" },
  { no: 4, name: "WELCOME" },
  { no: 5, name: "MOVE" },
  { no: 6, name: "PRESS" },
  { no: 7, name: "RELEASE" },
  { no: 8, name: "SUSTAIN" },
  { no: 9, name: "PROFILE" },
  { no: 10, name: "JOIN" },
  { no: 11, name: "LEAVE" },
  { no: 12, name: "RATELIMIT" },
  { no: 13, name: "MESSAGE" },
  { no: 14, name: "CHOWN" },
]);

/**
 * @generated from message pianoverse.ServerMessage.Chat
 */
export class ServerMessage_Chat extends Message<ServerMessage_Chat> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: string content = 2;
   */
  content = "";

  /**
   * @generated from field: string name = 3;
   */
  name = "";

  /**
   * @generated from field: string color = 4;
   */
  color = "";

  constructor(data?: PartialMessage<ServerMessage_Chat>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ServerMessage.Chat";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "content", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "color", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServerMessage_Chat {
    return new ServerMessage_Chat().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServerMessage_Chat {
    return new ServerMessage_Chat().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServerMessage_Chat {
    return new ServerMessage_Chat().fromJsonString(jsonString, options);
  }

  static equals(a: ServerMessage_Chat | PlainMessage<ServerMessage_Chat> | undefined, b: ServerMessage_Chat | PlainMessage<ServerMessage_Chat> | undefined): boolean {
    return proto3.util.equals(ServerMessage_Chat, a, b);
  }
}

/**
 * @generated from message pianoverse.ServerMessage.Room
 */
export class ServerMessage_Room extends Message<ServerMessage_Room> {
  /**
   * @generated from field: string room = 1;
   */
  room = "";

  /**
   * @generated from field: uint32 count = 2;
   */
  count = 0;

  constructor(data?: PartialMessage<ServerMessage_Room>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ServerMessage.Room";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "count", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServerMessage_Room {
    return new ServerMessage_Room().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServerMessage_Room {
    return new ServerMessage_Room().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServerMessage_Room {
    return new ServerMessage_Room().fromJsonString(jsonString, options);
  }

  static equals(a: ServerMessage_Room | PlainMessage<ServerMessage_Room> | undefined, b: ServerMessage_Room | PlainMessage<ServerMessage_Room> | undefined): boolean {
    return proto3.util.equals(ServerMessage_Room, a, b);
  }
}

/**
 * @generated from message pianoverse.ServerMessage.Welcome
 */
export class ServerMessage_Welcome extends Message<ServerMessage_Welcome> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string color = 3;
   */
  color = "";

  /**
   * @generated from field: string room = 4;
   */
  room = "";

  /**
   * @generated from field: string owner = 5;
   */
  owner = "";

  /**
   * @generated from field: repeated pianoverse.ServerMessage.Chat chat = 6;
   */
  chat: ServerMessage_Chat[] = [];

  /**
   * @generated from field: pianoverse.Role role = 7;
   */
  role = Role.USER;

  constructor(data?: PartialMessage<ServerMessage_Welcome>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ServerMessage.Welcome";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "color", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "room", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "chat", kind: "message", T: ServerMessage_Chat, repeated: true },
    { no: 7, name: "role", kind: "enum", T: proto3.getEnumType(Role) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServerMessage_Welcome {
    return new ServerMessage_Welcome().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServerMessage_Welcome {
    return new ServerMessage_Welcome().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServerMessage_Welcome {
    return new ServerMessage_Welcome().fromJsonString(jsonString, options);
  }

  static equals(a: ServerMessage_Welcome | PlainMessage<ServerMessage_Welcome> | undefined, b: ServerMessage_Welcome | PlainMessage<ServerMessage_Welcome> | undefined): boolean {
    return proto3.util.equals(ServerMessage_Welcome, a, b);
  }
}

/**
 * @generated from message pianoverse.ServerMessage.Sustain
 */
export class ServerMessage_Sustain extends Message<ServerMessage_Sustain> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: bool enabled = 2;
   */
  enabled = false;

  constructor(data?: PartialMessage<ServerMessage_Sustain>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ServerMessage.Sustain";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServerMessage_Sustain {
    return new ServerMessage_Sustain().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServerMessage_Sustain {
    return new ServerMessage_Sustain().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServerMessage_Sustain {
    return new ServerMessage_Sustain().fromJsonString(jsonString, options);
  }

  static equals(a: ServerMessage_Sustain | PlainMessage<ServerMessage_Sustain> | undefined, b: ServerMessage_Sustain | PlainMessage<ServerMessage_Sustain> | undefined): boolean {
    return proto3.util.equals(ServerMessage_Sustain, a, b);
  }
}

/**
 * @generated from message pianoverse.Profile
 */
export class Profile extends Message<Profile> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string color = 3;
   */
  color = "";

  /**
   * @generated from field: pianoverse.Role role = 4;
   */
  role = Role.USER;

  /**
   * @generated from field: bool muted = 5;
   */
  muted = false;

  /**
   * @generated from field: float x = 6;
   */
  x = 0;

  /**
   * @generated from field: float y = 7;
   */
  y = 0;

  constructor(data?: PartialMessage<Profile>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.Profile";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "color", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "role", kind: "enum", T: proto3.getEnumType(Role) },
    { no: 5, name: "muted", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 6, name: "x", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 7, name: "y", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Profile {
    return new Profile().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Profile {
    return new Profile().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Profile {
    return new Profile().fromJsonString(jsonString, options);
  }

  static equals(a: Profile | PlainMessage<Profile> | undefined, b: Profile | PlainMessage<Profile> | undefined): boolean {
    return proto3.util.equals(Profile, a, b);
  }
}

/**
 * @generated from message pianoverse.Move
 */
export class Move extends Message<Move> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: float x = 2;
   */
  x = 0;

  /**
   * @generated from field: float y = 3;
   */
  y = 0;

  constructor(data?: PartialMessage<Move>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.Move";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "x", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "y", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Move {
    return new Move().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Move {
    return new Move().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Move {
    return new Move().fromJsonString(jsonString, options);
  }

  static equals(a: Move | PlainMessage<Move> | undefined, b: Move | PlainMessage<Move> | undefined): boolean {
    return proto3.util.equals(Move, a, b);
  }
}

/**
 * @generated from message pianoverse.Press
 */
export class Press extends Message<Press> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: uint32 key = 2;
   */
  key = 0;

  /**
   * @generated from field: uint32 vel = 3;
   */
  vel = 0;

  constructor(data?: PartialMessage<Press>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.Press";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "key", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 3, name: "vel", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Press {
    return new Press().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Press {
    return new Press().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Press {
    return new Press().fromJsonString(jsonString, options);
  }

  static equals(a: Press | PlainMessage<Press> | undefined, b: Press | PlainMessage<Press> | undefined): boolean {
    return proto3.util.equals(Press, a, b);
  }
}

/**
 * @generated from message pianoverse.Release
 */
export class Release extends Message<Release> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: uint32 key = 2;
   */
  key = 0;

  constructor(data?: PartialMessage<Release>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.Release";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "key", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Release {
    return new Release().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Release {
    return new Release().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Release {
    return new Release().fromJsonString(jsonString, options);
  }

  static equals(a: Release | PlainMessage<Release> | undefined, b: Release | PlainMessage<Release> | undefined): boolean {
    return proto3.util.equals(Release, a, b);
  }
}