// @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 message pianoverse.ClientMessage
 */
export class ClientMessage extends Message<ClientMessage> {
  /**
   * @generated from field: pianoverse.ClientMessage.EventType event = 1;
   */
  event = ClientMessage_EventType.PING;

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

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

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

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

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

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

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

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

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

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

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

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

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

  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: "event", kind: "enum", T: proto3.getEnumType(ClientMessage_EventType) },
    { no: 3, name: "room", kind: "message", T: ClientMessage_Room },
    { no: 4, name: "profile", kind: "message", T: Profile },
    { no: 5, name: "chat", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "move", kind: "message", T: Move },
    { no: 7, name: "mute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "unmute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 9, name: "kick", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "press", kind: "message", T: Press },
    { no: 11, name: "release", kind: "message", T: Release },
    { no: 12, name: "sustain", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 13, name: "heartbeat", kind: "message", T: ClientMessage_Heartbeat },
    { no: 14, name: "ban", kind: "message", T: ClientMessage_Ban },
    { no: 15, name: "owner", 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: PING = 0;
   */
  PING = 0,

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @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 hours = 2;
   */
  hours = 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: "hours", 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.ServerMessage.EventType event = 1;
   */
  event = ServerMessage_EventType.PONG;

  /**
   * @generated from field: pianoverse.ServerMessage.Pong pong = 2;
   */
  pong?: ServerMessage_Pong;

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

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

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

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

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

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

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

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

  /**
   * @generated from field: pianoverse.ServerMessage.Join join = 11;
   */
  join?: ServerMessage_Join;

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

  /**
   * @generated from field: int32 rateLimit = 13;
   */
  rateLimit = 0;

  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: "event", kind: "enum", T: proto3.getEnumType(ServerMessage_EventType) },
    { no: 2, name: "pong", kind: "message", T: ServerMessage_Pong },
    { no: 3, name: "chat", kind: "message", T: ServerMessage_Chat },
    { no: 4, name: "rooms", kind: "message", T: ServerMessage_Room, repeated: true },
    { no: 5, name: "welcome", kind: "message", T: ServerMessage_Welcome },
    { no: 6, name: "move", kind: "message", T: Move },
    { no: 7, name: "press", kind: "message", T: Press },
    { no: 8, name: "release", kind: "message", T: Release },
    { no: 9, name: "sustain", kind: "message", T: ServerMessage_Sustain },
    { no: 10, name: "profile", kind: "message", T: Profile },
    { no: 11, name: "join", kind: "message", T: ServerMessage_Join },
    { no: 12, name: "leave", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 13, name: "rateLimit", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

  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: PONG = 0;
   */
  PONG = 0,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @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[] = [];

  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 },
  ]);

  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.ServerMessage.Join
 */
export class ServerMessage_Join extends Message<ServerMessage_Join> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

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

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

  /**
   * @generated from field: int32 role = 4;
   */
  role = 0;

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "pianoverse.ServerMessage.Join";
  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: "scalar", T: 5 /* ScalarType.INT32 */ },
    { 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>): ServerMessage_Join {
    return new ServerMessage_Join().fromBinary(bytes, options);
  }

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

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

  static equals(a: ServerMessage_Join | PlainMessage<ServerMessage_Join> | undefined, b: ServerMessage_Join | PlainMessage<ServerMessage_Join> | undefined): boolean {
    return proto3.util.equals(ServerMessage_Join, 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: string sound = 4;
   */
  sound = "";

  /**
   * @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: "sound", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { 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);
  }
}