SpotMicroESP32-Leika/app/src/lib/platform_shared/websocket_message.ts

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.10.1
//   protoc               v6.33.2
// source: platform_shared/websocket_message.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import type { FileDescriptorProto } from "ts-proto-descriptors";

export const protobufPackage = "";

export interface Vector {
  x: number;
  y: number;
}

export interface I2CDevice {
  address: number;
  partNumber: string;
  name: string;
}

export interface PinConfig {
  pin: number;
  mode: string;
  type: string;
  role: string;
}

export interface KnownNetworkItem {
  ssid: string;
  password: string;
  staticIp: boolean;
  localIp?: string | undefined;
  subnetMask?: string | undefined;
  gatewayIp?: string | undefined;
  dnsIp1?: string | undefined;
  dnsIp2?: string | undefined;
}

/** Individual message data types */
export interface IMUData {
  x: number;
  y: number;
  z: number;
  temp: number;
}

export interface IMUCalibrateData {
  success: boolean;
}

export interface ModeData {
  mode: number;
}

export interface ControllerInputData {
  left: Vector | undefined;
  right: Vector | undefined;
  height: number;
  speed: number;
  s1: number;
}

export interface AnalyticsData {
  maxAllocHeap: number;
  psramSize: number;
  freePsram: number;
  freeHeap: number;
  totalHeap: number;
  minFreeHeap: number;
  coreTemp: number;
  fsTotal: number;
  fsUsed: number;
  uptime: number;
  cpu0Usage: number;
  cpu1Usage: number;
  cpuUsage: number;
}

export interface AnglesData {
  angles: number[];
}

export interface I2CScanData {
  devices: I2CDevice[];
}

export interface PeripheralSettingsData {
  sda: number;
  scl: number;
  frequency: number;
  pins: PinConfig[];
}

export interface WifiSettingsData {
  hostname: string;
  priorityRssi: boolean;
  wifiNetworks: KnownNetworkItem[];
}

export interface RSSIData {
  rssi: number;
}

export interface DownloadOTAData {
  status: string;
  progress: number;
  error: string;
}

export interface SonarData {
  dummyField: string;
}

export interface SubscribeNotification {
  tag: number;
}

export interface UnsubscribeNotification {
  tag: number;
}

export interface PingMsg {
}

export interface PongMsg {
}

/**
 * WebSocket message wrapper
 * Only ONE field will be set at a time (oneof ensures this)
 */
export interface WebsocketMessage {
  subNotif?: SubscribeNotification | undefined;
  unsubNotif?: UnsubscribeNotification | undefined;
  pingmsg?: PingMsg | undefined;
  pongmsg?: PongMsg | undefined;
  imu?: IMUData | undefined;
  imuCalibrate?: IMUCalibrateData | undefined;
  mode?: ModeData | undefined;
  input?: ControllerInputData | undefined;
  analytics?: AnalyticsData | undefined;
  angles?: AnglesData | undefined;
  i2cScan?: I2CScanData | undefined;
  peripheralSettings?: PeripheralSettingsData | undefined;
  wifiSettings?: WifiSettingsData | undefined;
  rssi?: RSSIData | undefined;
}

function createBaseVector(): Vector {
  return { x: 0, y: 0 };
}

export const Vector: MessageFns<Vector> = {
  encode(message: Vector, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.x !== 0) {
      writer.uint32(13).float(message.x);
    }
    if (message.y !== 0) {
      writer.uint32(21).float(message.y);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): Vector {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseVector();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.x = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.y = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): Vector {
    return {
      x: isSet(object.x) ? globalThis.Number(object.x) : 0,
      y: isSet(object.y) ? globalThis.Number(object.y) : 0,
    };
  },

  toJSON(message: Vector): unknown {
    const obj: any = {};
    if (message.x !== 0) {
      obj.x = message.x;
    }
    if (message.y !== 0) {
      obj.y = message.y;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Vector>, I>>(base?: I): Vector {
    return Vector.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Vector>, I>>(object: I): Vector {
    const message = createBaseVector();
    message.x = object.x ?? 0;
    message.y = object.y ?? 0;
    return message;
  },
};

function createBaseI2CDevice(): I2CDevice {
  return { address: 0, partNumber: "", name: "" };
}

export const I2CDevice: MessageFns<I2CDevice> = {
  encode(message: I2CDevice, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.address !== 0) {
      writer.uint32(8).int32(message.address);
    }
    if (message.partNumber !== "") {
      writer.uint32(18).string(message.partNumber);
    }
    if (message.name !== "") {
      writer.uint32(26).string(message.name);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): I2CDevice {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseI2CDevice();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.address = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.partNumber = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.name = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): I2CDevice {
    return {
      address: isSet(object.address) ? globalThis.Number(object.address) : 0,
      partNumber: isSet(object.partNumber) ? globalThis.String(object.partNumber) : "",
      name: isSet(object.name) ? globalThis.String(object.name) : "",
    };
  },

  toJSON(message: I2CDevice): unknown {
    const obj: any = {};
    if (message.address !== 0) {
      obj.address = Math.round(message.address);
    }
    if (message.partNumber !== "") {
      obj.partNumber = message.partNumber;
    }
    if (message.name !== "") {
      obj.name = message.name;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<I2CDevice>, I>>(base?: I): I2CDevice {
    return I2CDevice.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<I2CDevice>, I>>(object: I): I2CDevice {
    const message = createBaseI2CDevice();
    message.address = object.address ?? 0;
    message.partNumber = object.partNumber ?? "";
    message.name = object.name ?? "";
    return message;
  },
};

function createBasePinConfig(): PinConfig {
  return { pin: 0, mode: "", type: "", role: "" };
}

export const PinConfig: MessageFns<PinConfig> = {
  encode(message: PinConfig, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.pin !== 0) {
      writer.uint32(8).int32(message.pin);
    }
    if (message.mode !== "") {
      writer.uint32(18).string(message.mode);
    }
    if (message.type !== "") {
      writer.uint32(26).string(message.type);
    }
    if (message.role !== "") {
      writer.uint32(34).string(message.role);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PinConfig {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePinConfig();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.pin = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.mode = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.type = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.role = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): PinConfig {
    return {
      pin: isSet(object.pin) ? globalThis.Number(object.pin) : 0,
      mode: isSet(object.mode) ? globalThis.String(object.mode) : "",
      type: isSet(object.type) ? globalThis.String(object.type) : "",
      role: isSet(object.role) ? globalThis.String(object.role) : "",
    };
  },

  toJSON(message: PinConfig): unknown {
    const obj: any = {};
    if (message.pin !== 0) {
      obj.pin = Math.round(message.pin);
    }
    if (message.mode !== "") {
      obj.mode = message.mode;
    }
    if (message.type !== "") {
      obj.type = message.type;
    }
    if (message.role !== "") {
      obj.role = message.role;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<PinConfig>, I>>(base?: I): PinConfig {
    return PinConfig.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PinConfig>, I>>(object: I): PinConfig {
    const message = createBasePinConfig();
    message.pin = object.pin ?? 0;
    message.mode = object.mode ?? "";
    message.type = object.type ?? "";
    message.role = object.role ?? "";
    return message;
  },
};

function createBaseKnownNetworkItem(): KnownNetworkItem {
  return {
    ssid: "",
    password: "",
    staticIp: false,
    localIp: undefined,
    subnetMask: undefined,
    gatewayIp: undefined,
    dnsIp1: undefined,
    dnsIp2: undefined,
  };
}

export const KnownNetworkItem: MessageFns<KnownNetworkItem> = {
  encode(message: KnownNetworkItem, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.ssid !== "") {
      writer.uint32(10).string(message.ssid);
    }
    if (message.password !== "") {
      writer.uint32(18).string(message.password);
    }
    if (message.staticIp !== false) {
      writer.uint32(24).bool(message.staticIp);
    }
    if (message.localIp !== undefined) {
      writer.uint32(34).string(message.localIp);
    }
    if (message.subnetMask !== undefined) {
      writer.uint32(42).string(message.subnetMask);
    }
    if (message.gatewayIp !== undefined) {
      writer.uint32(50).string(message.gatewayIp);
    }
    if (message.dnsIp1 !== undefined) {
      writer.uint32(58).string(message.dnsIp1);
    }
    if (message.dnsIp2 !== undefined) {
      writer.uint32(66).string(message.dnsIp2);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): KnownNetworkItem {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseKnownNetworkItem();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.ssid = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.password = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.staticIp = reader.bool();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.localIp = reader.string();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          message.subnetMask = reader.string();
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.gatewayIp = reader.string();
          continue;
        }
        case 7: {
          if (tag !== 58) {
            break;
          }

          message.dnsIp1 = reader.string();
          continue;
        }
        case 8: {
          if (tag !== 66) {
            break;
          }

          message.dnsIp2 = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): KnownNetworkItem {
    return {
      ssid: isSet(object.ssid) ? globalThis.String(object.ssid) : "",
      password: isSet(object.password) ? globalThis.String(object.password) : "",
      staticIp: isSet(object.staticIp) ? globalThis.Boolean(object.staticIp) : false,
      localIp: isSet(object.localIp) ? globalThis.String(object.localIp) : undefined,
      subnetMask: isSet(object.subnetMask) ? globalThis.String(object.subnetMask) : undefined,
      gatewayIp: isSet(object.gatewayIp) ? globalThis.String(object.gatewayIp) : undefined,
      dnsIp1: isSet(object.dnsIp1) ? globalThis.String(object.dnsIp1) : undefined,
      dnsIp2: isSet(object.dnsIp2) ? globalThis.String(object.dnsIp2) : undefined,
    };
  },

  toJSON(message: KnownNetworkItem): unknown {
    const obj: any = {};
    if (message.ssid !== "") {
      obj.ssid = message.ssid;
    }
    if (message.password !== "") {
      obj.password = message.password;
    }
    if (message.staticIp !== false) {
      obj.staticIp = message.staticIp;
    }
    if (message.localIp !== undefined) {
      obj.localIp = message.localIp;
    }
    if (message.subnetMask !== undefined) {
      obj.subnetMask = message.subnetMask;
    }
    if (message.gatewayIp !== undefined) {
      obj.gatewayIp = message.gatewayIp;
    }
    if (message.dnsIp1 !== undefined) {
      obj.dnsIp1 = message.dnsIp1;
    }
    if (message.dnsIp2 !== undefined) {
      obj.dnsIp2 = message.dnsIp2;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<KnownNetworkItem>, I>>(base?: I): KnownNetworkItem {
    return KnownNetworkItem.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<KnownNetworkItem>, I>>(object: I): KnownNetworkItem {
    const message = createBaseKnownNetworkItem();
    message.ssid = object.ssid ?? "";
    message.password = object.password ?? "";
    message.staticIp = object.staticIp ?? false;
    message.localIp = object.localIp ?? undefined;
    message.subnetMask = object.subnetMask ?? undefined;
    message.gatewayIp = object.gatewayIp ?? undefined;
    message.dnsIp1 = object.dnsIp1 ?? undefined;
    message.dnsIp2 = object.dnsIp2 ?? undefined;
    return message;
  },
};

function createBaseIMUData(): IMUData {
  return { x: 0, y: 0, z: 0, temp: 0 };
}

export const IMUData: MessageFns<IMUData> = {
  encode(message: IMUData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.x !== 0) {
      writer.uint32(13).float(message.x);
    }
    if (message.y !== 0) {
      writer.uint32(21).float(message.y);
    }
    if (message.z !== 0) {
      writer.uint32(29).float(message.z);
    }
    if (message.temp !== 0) {
      writer.uint32(37).float(message.temp);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): IMUData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseIMUData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 13) {
            break;
          }

          message.x = reader.float();
          continue;
        }
        case 2: {
          if (tag !== 21) {
            break;
          }

          message.y = reader.float();
          continue;
        }
        case 3: {
          if (tag !== 29) {
            break;
          }

          message.z = reader.float();
          continue;
        }
        case 4: {
          if (tag !== 37) {
            break;
          }

          message.temp = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): IMUData {
    return {
      x: isSet(object.x) ? globalThis.Number(object.x) : 0,
      y: isSet(object.y) ? globalThis.Number(object.y) : 0,
      z: isSet(object.z) ? globalThis.Number(object.z) : 0,
      temp: isSet(object.temp) ? globalThis.Number(object.temp) : 0,
    };
  },

  toJSON(message: IMUData): unknown {
    const obj: any = {};
    if (message.x !== 0) {
      obj.x = message.x;
    }
    if (message.y !== 0) {
      obj.y = message.y;
    }
    if (message.z !== 0) {
      obj.z = message.z;
    }
    if (message.temp !== 0) {
      obj.temp = message.temp;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<IMUData>, I>>(base?: I): IMUData {
    return IMUData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<IMUData>, I>>(object: I): IMUData {
    const message = createBaseIMUData();
    message.x = object.x ?? 0;
    message.y = object.y ?? 0;
    message.z = object.z ?? 0;
    message.temp = object.temp ?? 0;
    return message;
  },
};

function createBaseIMUCalibrateData(): IMUCalibrateData {
  return { success: false };
}

export const IMUCalibrateData: MessageFns<IMUCalibrateData> = {
  encode(message: IMUCalibrateData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.success !== false) {
      writer.uint32(8).bool(message.success);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): IMUCalibrateData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseIMUCalibrateData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.success = reader.bool();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): IMUCalibrateData {
    return { success: isSet(object.success) ? globalThis.Boolean(object.success) : false };
  },

  toJSON(message: IMUCalibrateData): unknown {
    const obj: any = {};
    if (message.success !== false) {
      obj.success = message.success;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<IMUCalibrateData>, I>>(base?: I): IMUCalibrateData {
    return IMUCalibrateData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<IMUCalibrateData>, I>>(object: I): IMUCalibrateData {
    const message = createBaseIMUCalibrateData();
    message.success = object.success ?? false;
    return message;
  },
};

function createBaseModeData(): ModeData {
  return { mode: 0 };
}

export const ModeData: MessageFns<ModeData> = {
  encode(message: ModeData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.mode !== 0) {
      writer.uint32(8).int32(message.mode);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ModeData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseModeData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.mode = reader.int32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ModeData {
    return { mode: isSet(object.mode) ? globalThis.Number(object.mode) : 0 };
  },

  toJSON(message: ModeData): unknown {
    const obj: any = {};
    if (message.mode !== 0) {
      obj.mode = Math.round(message.mode);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ModeData>, I>>(base?: I): ModeData {
    return ModeData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ModeData>, I>>(object: I): ModeData {
    const message = createBaseModeData();
    message.mode = object.mode ?? 0;
    return message;
  },
};

function createBaseControllerInputData(): ControllerInputData {
  return { left: undefined, right: undefined, height: 0, speed: 0, s1: 0 };
}

export const ControllerInputData: MessageFns<ControllerInputData> = {
  encode(message: ControllerInputData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.left !== undefined) {
      Vector.encode(message.left, writer.uint32(10).fork()).join();
    }
    if (message.right !== undefined) {
      Vector.encode(message.right, writer.uint32(18).fork()).join();
    }
    if (message.height !== 0) {
      writer.uint32(29).float(message.height);
    }
    if (message.speed !== 0) {
      writer.uint32(37).float(message.speed);
    }
    if (message.s1 !== 0) {
      writer.uint32(45).float(message.s1);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ControllerInputData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseControllerInputData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.left = Vector.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.right = Vector.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 29) {
            break;
          }

          message.height = reader.float();
          continue;
        }
        case 4: {
          if (tag !== 37) {
            break;
          }

          message.speed = reader.float();
          continue;
        }
        case 5: {
          if (tag !== 45) {
            break;
          }

          message.s1 = reader.float();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ControllerInputData {
    return {
      left: isSet(object.left) ? Vector.fromJSON(object.left) : undefined,
      right: isSet(object.right) ? Vector.fromJSON(object.right) : undefined,
      height: isSet(object.height) ? globalThis.Number(object.height) : 0,
      speed: isSet(object.speed) ? globalThis.Number(object.speed) : 0,
      s1: isSet(object.s1) ? globalThis.Number(object.s1) : 0,
    };
  },

  toJSON(message: ControllerInputData): unknown {
    const obj: any = {};
    if (message.left !== undefined) {
      obj.left = Vector.toJSON(message.left);
    }
    if (message.right !== undefined) {
      obj.right = Vector.toJSON(message.right);
    }
    if (message.height !== 0) {
      obj.height = message.height;
    }
    if (message.speed !== 0) {
      obj.speed = message.speed;
    }
    if (message.s1 !== 0) {
      obj.s1 = message.s1;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ControllerInputData>, I>>(base?: I): ControllerInputData {
    return ControllerInputData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ControllerInputData>, I>>(object: I): ControllerInputData {
    const message = createBaseControllerInputData();
    message.left = (object.left !== undefined && object.left !== null) ? Vector.fromPartial(object.left) : undefined;
    message.right = (object.right !== undefined && object.right !== null)
      ? Vector.fromPartial(object.right)
      : undefined;
    message.height = object.height ?? 0;
    message.speed = object.speed ?? 0;
    message.s1 = object.s1 ?? 0;
    return message;
  },
};

function createBaseAnalyticsData(): AnalyticsData {
  return {
    maxAllocHeap: 0,
    psramSize: 0,
    freePsram: 0,
    freeHeap: 0,
    totalHeap: 0,
    minFreeHeap: 0,
    coreTemp: 0,
    fsTotal: 0,
    fsUsed: 0,
    uptime: 0,
    cpu0Usage: 0,
    cpu1Usage: 0,
    cpuUsage: 0,
  };
}

export const AnalyticsData: MessageFns<AnalyticsData> = {
  encode(message: AnalyticsData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.maxAllocHeap !== 0) {
      writer.uint32(8).int32(message.maxAllocHeap);
    }
    if (message.psramSize !== 0) {
      writer.uint32(16).int32(message.psramSize);
    }
    if (message.freePsram !== 0) {
      writer.uint32(24).int32(message.freePsram);
    }
    if (message.freeHeap !== 0) {
      writer.uint32(32).int32(message.freeHeap);
    }
    if (message.totalHeap !== 0) {
      writer.uint32(40).int32(message.totalHeap);
    }
    if (message.minFreeHeap !== 0) {
      writer.uint32(48).int32(message.minFreeHeap);
    }
    if (message.coreTemp !== 0) {
      writer.uint32(61).float(message.coreTemp);
    }
    if (message.fsTotal !== 0) {
      writer.uint32(64).int32(message.fsTotal);
    }
    if (message.fsUsed !== 0) {
      writer.uint32(72).int32(message.fsUsed);
    }
    if (message.uptime !== 0) {
      writer.uint32(80).int64(message.uptime);
    }
    if (message.cpu0Usage !== 0) {
      writer.uint32(88).int32(message.cpu0Usage);
    }
    if (message.cpu1Usage !== 0) {
      writer.uint32(96).int32(message.cpu1Usage);
    }
    if (message.cpuUsage !== 0) {
      writer.uint32(104).int32(message.cpuUsage);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): AnalyticsData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAnalyticsData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.maxAllocHeap = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.psramSize = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.freePsram = reader.int32();
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.freeHeap = reader.int32();
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.totalHeap = reader.int32();
          continue;
        }
        case 6: {
          if (tag !== 48) {
            break;
          }

          message.minFreeHeap = reader.int32();
          continue;
        }
        case 7: {
          if (tag !== 61) {
            break;
          }

          message.coreTemp = reader.float();
          continue;
        }
        case 8: {
          if (tag !== 64) {
            break;
          }

          message.fsTotal = reader.int32();
          continue;
        }
        case 9: {
          if (tag !== 72) {
            break;
          }

          message.fsUsed = reader.int32();
          continue;
        }
        case 10: {
          if (tag !== 80) {
            break;
          }

          message.uptime = longToNumber(reader.int64());
          continue;
        }
        case 11: {
          if (tag !== 88) {
            break;
          }

          message.cpu0Usage = reader.int32();
          continue;
        }
        case 12: {
          if (tag !== 96) {
            break;
          }

          message.cpu1Usage = reader.int32();
          continue;
        }
        case 13: {
          if (tag !== 104) {
            break;
          }

          message.cpuUsage = reader.int32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): AnalyticsData {
    return {
      maxAllocHeap: isSet(object.maxAllocHeap) ? globalThis.Number(object.maxAllocHeap) : 0,
      psramSize: isSet(object.psramSize) ? globalThis.Number(object.psramSize) : 0,
      freePsram: isSet(object.freePsram) ? globalThis.Number(object.freePsram) : 0,
      freeHeap: isSet(object.freeHeap) ? globalThis.Number(object.freeHeap) : 0,
      totalHeap: isSet(object.totalHeap) ? globalThis.Number(object.totalHeap) : 0,
      minFreeHeap: isSet(object.minFreeHeap) ? globalThis.Number(object.minFreeHeap) : 0,
      coreTemp: isSet(object.coreTemp) ? globalThis.Number(object.coreTemp) : 0,
      fsTotal: isSet(object.fsTotal) ? globalThis.Number(object.fsTotal) : 0,
      fsUsed: isSet(object.fsUsed) ? globalThis.Number(object.fsUsed) : 0,
      uptime: isSet(object.uptime) ? globalThis.Number(object.uptime) : 0,
      cpu0Usage: isSet(object.cpu0Usage) ? globalThis.Number(object.cpu0Usage) : 0,
      cpu1Usage: isSet(object.cpu1Usage) ? globalThis.Number(object.cpu1Usage) : 0,
      cpuUsage: isSet(object.cpuUsage) ? globalThis.Number(object.cpuUsage) : 0,
    };
  },

  toJSON(message: AnalyticsData): unknown {
    const obj: any = {};
    if (message.maxAllocHeap !== 0) {
      obj.maxAllocHeap = Math.round(message.maxAllocHeap);
    }
    if (message.psramSize !== 0) {
      obj.psramSize = Math.round(message.psramSize);
    }
    if (message.freePsram !== 0) {
      obj.freePsram = Math.round(message.freePsram);
    }
    if (message.freeHeap !== 0) {
      obj.freeHeap = Math.round(message.freeHeap);
    }
    if (message.totalHeap !== 0) {
      obj.totalHeap = Math.round(message.totalHeap);
    }
    if (message.minFreeHeap !== 0) {
      obj.minFreeHeap = Math.round(message.minFreeHeap);
    }
    if (message.coreTemp !== 0) {
      obj.coreTemp = message.coreTemp;
    }
    if (message.fsTotal !== 0) {
      obj.fsTotal = Math.round(message.fsTotal);
    }
    if (message.fsUsed !== 0) {
      obj.fsUsed = Math.round(message.fsUsed);
    }
    if (message.uptime !== 0) {
      obj.uptime = Math.round(message.uptime);
    }
    if (message.cpu0Usage !== 0) {
      obj.cpu0Usage = Math.round(message.cpu0Usage);
    }
    if (message.cpu1Usage !== 0) {
      obj.cpu1Usage = Math.round(message.cpu1Usage);
    }
    if (message.cpuUsage !== 0) {
      obj.cpuUsage = Math.round(message.cpuUsage);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AnalyticsData>, I>>(base?: I): AnalyticsData {
    return AnalyticsData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AnalyticsData>, I>>(object: I): AnalyticsData {
    const message = createBaseAnalyticsData();
    message.maxAllocHeap = object.maxAllocHeap ?? 0;
    message.psramSize = object.psramSize ?? 0;
    message.freePsram = object.freePsram ?? 0;
    message.freeHeap = object.freeHeap ?? 0;
    message.totalHeap = object.totalHeap ?? 0;
    message.minFreeHeap = object.minFreeHeap ?? 0;
    message.coreTemp = object.coreTemp ?? 0;
    message.fsTotal = object.fsTotal ?? 0;
    message.fsUsed = object.fsUsed ?? 0;
    message.uptime = object.uptime ?? 0;
    message.cpu0Usage = object.cpu0Usage ?? 0;
    message.cpu1Usage = object.cpu1Usage ?? 0;
    message.cpuUsage = object.cpuUsage ?? 0;
    return message;
  },
};

function createBaseAnglesData(): AnglesData {
  return { angles: [] };
}

export const AnglesData: MessageFns<AnglesData> = {
  encode(message: AnglesData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    writer.uint32(10).fork();
    for (const v of message.angles) {
      writer.int32(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): AnglesData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAnglesData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag === 8) {
            message.angles.push(reader.int32());

            continue;
          }

          if (tag === 10) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.angles.push(reader.int32());
            }

            continue;
          }

          break;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): AnglesData {
    return {
      angles: globalThis.Array.isArray(object?.angles) ? object.angles.map((e: any) => globalThis.Number(e)) : [],
    };
  },

  toJSON(message: AnglesData): unknown {
    const obj: any = {};
    if (message.angles?.length) {
      obj.angles = message.angles.map((e) => Math.round(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AnglesData>, I>>(base?: I): AnglesData {
    return AnglesData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AnglesData>, I>>(object: I): AnglesData {
    const message = createBaseAnglesData();
    message.angles = object.angles?.map((e) => e) || [];
    return message;
  },
};

function createBaseI2CScanData(): I2CScanData {
  return { devices: [] };
}

export const I2CScanData: MessageFns<I2CScanData> = {
  encode(message: I2CScanData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.devices) {
      I2CDevice.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): I2CScanData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseI2CScanData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.devices.push(I2CDevice.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): I2CScanData {
    return {
      devices: globalThis.Array.isArray(object?.devices) ? object.devices.map((e: any) => I2CDevice.fromJSON(e)) : [],
    };
  },

  toJSON(message: I2CScanData): unknown {
    const obj: any = {};
    if (message.devices?.length) {
      obj.devices = message.devices.map((e) => I2CDevice.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<I2CScanData>, I>>(base?: I): I2CScanData {
    return I2CScanData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<I2CScanData>, I>>(object: I): I2CScanData {
    const message = createBaseI2CScanData();
    message.devices = object.devices?.map((e) => I2CDevice.fromPartial(e)) || [];
    return message;
  },
};

function createBasePeripheralSettingsData(): PeripheralSettingsData {
  return { sda: 0, scl: 0, frequency: 0, pins: [] };
}

export const PeripheralSettingsData: MessageFns<PeripheralSettingsData> = {
  encode(message: PeripheralSettingsData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.sda !== 0) {
      writer.uint32(8).int32(message.sda);
    }
    if (message.scl !== 0) {
      writer.uint32(16).int32(message.scl);
    }
    if (message.frequency !== 0) {
      writer.uint32(24).int32(message.frequency);
    }
    for (const v of message.pins) {
      PinConfig.encode(v!, writer.uint32(34).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PeripheralSettingsData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePeripheralSettingsData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.sda = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.scl = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.frequency = reader.int32();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.pins.push(PinConfig.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): PeripheralSettingsData {
    return {
      sda: isSet(object.sda) ? globalThis.Number(object.sda) : 0,
      scl: isSet(object.scl) ? globalThis.Number(object.scl) : 0,
      frequency: isSet(object.frequency) ? globalThis.Number(object.frequency) : 0,
      pins: globalThis.Array.isArray(object?.pins) ? object.pins.map((e: any) => PinConfig.fromJSON(e)) : [],
    };
  },

  toJSON(message: PeripheralSettingsData): unknown {
    const obj: any = {};
    if (message.sda !== 0) {
      obj.sda = Math.round(message.sda);
    }
    if (message.scl !== 0) {
      obj.scl = Math.round(message.scl);
    }
    if (message.frequency !== 0) {
      obj.frequency = Math.round(message.frequency);
    }
    if (message.pins?.length) {
      obj.pins = message.pins.map((e) => PinConfig.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<PeripheralSettingsData>, I>>(base?: I): PeripheralSettingsData {
    return PeripheralSettingsData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PeripheralSettingsData>, I>>(object: I): PeripheralSettingsData {
    const message = createBasePeripheralSettingsData();
    message.sda = object.sda ?? 0;
    message.scl = object.scl ?? 0;
    message.frequency = object.frequency ?? 0;
    message.pins = object.pins?.map((e) => PinConfig.fromPartial(e)) || [];
    return message;
  },
};

function createBaseWifiSettingsData(): WifiSettingsData {
  return { hostname: "", priorityRssi: false, wifiNetworks: [] };
}

export const WifiSettingsData: MessageFns<WifiSettingsData> = {
  encode(message: WifiSettingsData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.hostname !== "") {
      writer.uint32(10).string(message.hostname);
    }
    if (message.priorityRssi !== false) {
      writer.uint32(16).bool(message.priorityRssi);
    }
    for (const v of message.wifiNetworks) {
      KnownNetworkItem.encode(v!, writer.uint32(26).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): WifiSettingsData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseWifiSettingsData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.hostname = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.priorityRssi = reader.bool();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.wifiNetworks.push(KnownNetworkItem.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): WifiSettingsData {
    return {
      hostname: isSet(object.hostname) ? globalThis.String(object.hostname) : "",
      priorityRssi: isSet(object.priorityRssi) ? globalThis.Boolean(object.priorityRssi) : false,
      wifiNetworks: globalThis.Array.isArray(object?.wifiNetworks)
        ? object.wifiNetworks.map((e: any) => KnownNetworkItem.fromJSON(e))
        : [],
    };
  },

  toJSON(message: WifiSettingsData): unknown {
    const obj: any = {};
    if (message.hostname !== "") {
      obj.hostname = message.hostname;
    }
    if (message.priorityRssi !== false) {
      obj.priorityRssi = message.priorityRssi;
    }
    if (message.wifiNetworks?.length) {
      obj.wifiNetworks = message.wifiNetworks.map((e) => KnownNetworkItem.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<WifiSettingsData>, I>>(base?: I): WifiSettingsData {
    return WifiSettingsData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<WifiSettingsData>, I>>(object: I): WifiSettingsData {
    const message = createBaseWifiSettingsData();
    message.hostname = object.hostname ?? "";
    message.priorityRssi = object.priorityRssi ?? false;
    message.wifiNetworks = object.wifiNetworks?.map((e) => KnownNetworkItem.fromPartial(e)) || [];
    return message;
  },
};

function createBaseRSSIData(): RSSIData {
  return { rssi: 0 };
}

export const RSSIData: MessageFns<RSSIData> = {
  encode(message: RSSIData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.rssi !== 0) {
      writer.uint32(8).int32(message.rssi);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): RSSIData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseRSSIData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.rssi = reader.int32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): RSSIData {
    return { rssi: isSet(object.rssi) ? globalThis.Number(object.rssi) : 0 };
  },

  toJSON(message: RSSIData): unknown {
    const obj: any = {};
    if (message.rssi !== 0) {
      obj.rssi = Math.round(message.rssi);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<RSSIData>, I>>(base?: I): RSSIData {
    return RSSIData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<RSSIData>, I>>(object: I): RSSIData {
    const message = createBaseRSSIData();
    message.rssi = object.rssi ?? 0;
    return message;
  },
};

function createBaseDownloadOTAData(): DownloadOTAData {
  return { status: "", progress: 0, error: "" };
}

export const DownloadOTAData: MessageFns<DownloadOTAData> = {
  encode(message: DownloadOTAData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.status !== "") {
      writer.uint32(10).string(message.status);
    }
    if (message.progress !== 0) {
      writer.uint32(16).int32(message.progress);
    }
    if (message.error !== "") {
      writer.uint32(26).string(message.error);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): DownloadOTAData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseDownloadOTAData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.status = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.progress = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.error = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): DownloadOTAData {
    return {
      status: isSet(object.status) ? globalThis.String(object.status) : "",
      progress: isSet(object.progress) ? globalThis.Number(object.progress) : 0,
      error: isSet(object.error) ? globalThis.String(object.error) : "",
    };
  },

  toJSON(message: DownloadOTAData): unknown {
    const obj: any = {};
    if (message.status !== "") {
      obj.status = message.status;
    }
    if (message.progress !== 0) {
      obj.progress = Math.round(message.progress);
    }
    if (message.error !== "") {
      obj.error = message.error;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<DownloadOTAData>, I>>(base?: I): DownloadOTAData {
    return DownloadOTAData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<DownloadOTAData>, I>>(object: I): DownloadOTAData {
    const message = createBaseDownloadOTAData();
    message.status = object.status ?? "";
    message.progress = object.progress ?? 0;
    message.error = object.error ?? "";
    return message;
  },
};

function createBaseSonarData(): SonarData {
  return { dummyField: "" };
}

export const SonarData: MessageFns<SonarData> = {
  encode(message: SonarData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.dummyField !== "") {
      writer.uint32(10).string(message.dummyField);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): SonarData {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSonarData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.dummyField = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): SonarData {
    return { dummyField: isSet(object.dummyField) ? globalThis.String(object.dummyField) : "" };
  },

  toJSON(message: SonarData): unknown {
    const obj: any = {};
    if (message.dummyField !== "") {
      obj.dummyField = message.dummyField;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<SonarData>, I>>(base?: I): SonarData {
    return SonarData.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<SonarData>, I>>(object: I): SonarData {
    const message = createBaseSonarData();
    message.dummyField = object.dummyField ?? "";
    return message;
  },
};

function createBaseSubscribeNotification(): SubscribeNotification {
  return { tag: 0 };
}

export const SubscribeNotification: MessageFns<SubscribeNotification> = {
  encode(message: SubscribeNotification, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.tag !== 0) {
      writer.uint32(8).int32(message.tag);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): SubscribeNotification {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSubscribeNotification();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.tag = reader.int32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): SubscribeNotification {
    return { tag: isSet(object.tag) ? globalThis.Number(object.tag) : 0 };
  },

  toJSON(message: SubscribeNotification): unknown {
    const obj: any = {};
    if (message.tag !== 0) {
      obj.tag = Math.round(message.tag);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<SubscribeNotification>, I>>(base?: I): SubscribeNotification {
    return SubscribeNotification.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<SubscribeNotification>, I>>(object: I): SubscribeNotification {
    const message = createBaseSubscribeNotification();
    message.tag = object.tag ?? 0;
    return message;
  },
};

function createBaseUnsubscribeNotification(): UnsubscribeNotification {
  return { tag: 0 };
}

export const UnsubscribeNotification: MessageFns<UnsubscribeNotification> = {
  encode(message: UnsubscribeNotification, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.tag !== 0) {
      writer.uint32(8).int32(message.tag);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): UnsubscribeNotification {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseUnsubscribeNotification();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.tag = reader.int32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): UnsubscribeNotification {
    return { tag: isSet(object.tag) ? globalThis.Number(object.tag) : 0 };
  },

  toJSON(message: UnsubscribeNotification): unknown {
    const obj: any = {};
    if (message.tag !== 0) {
      obj.tag = Math.round(message.tag);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<UnsubscribeNotification>, I>>(base?: I): UnsubscribeNotification {
    return UnsubscribeNotification.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<UnsubscribeNotification>, I>>(object: I): UnsubscribeNotification {
    const message = createBaseUnsubscribeNotification();
    message.tag = object.tag ?? 0;
    return message;
  },
};

function createBasePingMsg(): PingMsg {
  return {};
}

export const PingMsg: MessageFns<PingMsg> = {
  encode(_: PingMsg, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PingMsg {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePingMsg();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): PingMsg {
    return {};
  },

  toJSON(_: PingMsg): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<PingMsg>, I>>(base?: I): PingMsg {
    return PingMsg.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PingMsg>, I>>(_: I): PingMsg {
    const message = createBasePingMsg();
    return message;
  },
};

function createBasePongMsg(): PongMsg {
  return {};
}

export const PongMsg: MessageFns<PongMsg> = {
  encode(_: PongMsg, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PongMsg {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePongMsg();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): PongMsg {
    return {};
  },

  toJSON(_: PongMsg): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<PongMsg>, I>>(base?: I): PongMsg {
    return PongMsg.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PongMsg>, I>>(_: I): PongMsg {
    const message = createBasePongMsg();
    return message;
  },
};

function createBaseWebsocketMessage(): WebsocketMessage {
  return {
    subNotif: undefined,
    unsubNotif: undefined,
    pingmsg: undefined,
    pongmsg: undefined,
    imu: undefined,
    imuCalibrate: undefined,
    mode: undefined,
    input: undefined,
    analytics: undefined,
    angles: undefined,
    i2cScan: undefined,
    peripheralSettings: undefined,
    wifiSettings: undefined,
    rssi: undefined,
  };
}

export const WebsocketMessage: MessageFns<WebsocketMessage> = {
  encode(message: WebsocketMessage, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.subNotif !== undefined) {
      SubscribeNotification.encode(message.subNotif, writer.uint32(162).fork()).join();
    }
    if (message.unsubNotif !== undefined) {
      UnsubscribeNotification.encode(message.unsubNotif, writer.uint32(170).fork()).join();
    }
    if (message.pingmsg !== undefined) {
      PingMsg.encode(message.pingmsg, writer.uint32(242).fork()).join();
    }
    if (message.pongmsg !== undefined) {
      PongMsg.encode(message.pongmsg, writer.uint32(250).fork()).join();
    }
    if (message.imu !== undefined) {
      IMUData.encode(message.imu, writer.uint32(882).fork()).join();
    }
    if (message.imuCalibrate !== undefined) {
      IMUCalibrateData.encode(message.imuCalibrate, writer.uint32(962).fork()).join();
    }
    if (message.mode !== undefined) {
      ModeData.encode(message.mode, writer.uint32(1042).fork()).join();
    }
    if (message.input !== undefined) {
      ControllerInputData.encode(message.input, writer.uint32(1122).fork()).join();
    }
    if (message.analytics !== undefined) {
      AnalyticsData.encode(message.analytics, writer.uint32(1202).fork()).join();
    }
    if (message.angles !== undefined) {
      AnglesData.encode(message.angles, writer.uint32(1362).fork()).join();
    }
    if (message.i2cScan !== undefined) {
      I2CScanData.encode(message.i2cScan, writer.uint32(1442).fork()).join();
    }
    if (message.peripheralSettings !== undefined) {
      PeripheralSettingsData.encode(message.peripheralSettings, writer.uint32(1522).fork()).join();
    }
    if (message.wifiSettings !== undefined) {
      WifiSettingsData.encode(message.wifiSettings, writer.uint32(1922).fork()).join();
    }
    if (message.rssi !== undefined) {
      RSSIData.encode(message.rssi, writer.uint32(2082).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): WebsocketMessage {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseWebsocketMessage();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 20: {
          if (tag !== 162) {
            break;
          }

          message.subNotif = SubscribeNotification.decode(reader, reader.uint32());
          continue;
        }
        case 21: {
          if (tag !== 170) {
            break;
          }

          message.unsubNotif = UnsubscribeNotification.decode(reader, reader.uint32());
          continue;
        }
        case 30: {
          if (tag !== 242) {
            break;
          }

          message.pingmsg = PingMsg.decode(reader, reader.uint32());
          continue;
        }
        case 31: {
          if (tag !== 250) {
            break;
          }

          message.pongmsg = PongMsg.decode(reader, reader.uint32());
          continue;
        }
        case 110: {
          if (tag !== 882) {
            break;
          }

          message.imu = IMUData.decode(reader, reader.uint32());
          continue;
        }
        case 120: {
          if (tag !== 962) {
            break;
          }

          message.imuCalibrate = IMUCalibrateData.decode(reader, reader.uint32());
          continue;
        }
        case 130: {
          if (tag !== 1042) {
            break;
          }

          message.mode = ModeData.decode(reader, reader.uint32());
          continue;
        }
        case 140: {
          if (tag !== 1122) {
            break;
          }

          message.input = ControllerInputData.decode(reader, reader.uint32());
          continue;
        }
        case 150: {
          if (tag !== 1202) {
            break;
          }

          message.analytics = AnalyticsData.decode(reader, reader.uint32());
          continue;
        }
        case 170: {
          if (tag !== 1362) {
            break;
          }

          message.angles = AnglesData.decode(reader, reader.uint32());
          continue;
        }
        case 180: {
          if (tag !== 1442) {
            break;
          }

          message.i2cScan = I2CScanData.decode(reader, reader.uint32());
          continue;
        }
        case 190: {
          if (tag !== 1522) {
            break;
          }

          message.peripheralSettings = PeripheralSettingsData.decode(reader, reader.uint32());
          continue;
        }
        case 240: {
          if (tag !== 1922) {
            break;
          }

          message.wifiSettings = WifiSettingsData.decode(reader, reader.uint32());
          continue;
        }
        case 260: {
          if (tag !== 2082) {
            break;
          }

          message.rssi = RSSIData.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): WebsocketMessage {
    return {
      subNotif: isSet(object.subNotif) ? SubscribeNotification.fromJSON(object.subNotif) : undefined,
      unsubNotif: isSet(object.unsubNotif) ? UnsubscribeNotification.fromJSON(object.unsubNotif) : undefined,
      pingmsg: isSet(object.pingmsg) ? PingMsg.fromJSON(object.pingmsg) : undefined,
      pongmsg: isSet(object.pongmsg) ? PongMsg.fromJSON(object.pongmsg) : undefined,
      imu: isSet(object.imu) ? IMUData.fromJSON(object.imu) : undefined,
      imuCalibrate: isSet(object.imuCalibrate) ? IMUCalibrateData.fromJSON(object.imuCalibrate) : undefined,
      mode: isSet(object.mode) ? ModeData.fromJSON(object.mode) : undefined,
      input: isSet(object.input) ? ControllerInputData.fromJSON(object.input) : undefined,
      analytics: isSet(object.analytics) ? AnalyticsData.fromJSON(object.analytics) : undefined,
      angles: isSet(object.angles) ? AnglesData.fromJSON(object.angles) : undefined,
      i2cScan: isSet(object.i2cScan) ? I2CScanData.fromJSON(object.i2cScan) : undefined,
      peripheralSettings: isSet(object.peripheralSettings)
        ? PeripheralSettingsData.fromJSON(object.peripheralSettings)
        : undefined,
      wifiSettings: isSet(object.wifiSettings) ? WifiSettingsData.fromJSON(object.wifiSettings) : undefined,
      rssi: isSet(object.rssi) ? RSSIData.fromJSON(object.rssi) : undefined,
    };
  },

  toJSON(message: WebsocketMessage): unknown {
    const obj: any = {};
    if (message.subNotif !== undefined) {
      obj.subNotif = SubscribeNotification.toJSON(message.subNotif);
    }
    if (message.unsubNotif !== undefined) {
      obj.unsubNotif = UnsubscribeNotification.toJSON(message.unsubNotif);
    }
    if (message.pingmsg !== undefined) {
      obj.pingmsg = PingMsg.toJSON(message.pingmsg);
    }
    if (message.pongmsg !== undefined) {
      obj.pongmsg = PongMsg.toJSON(message.pongmsg);
    }
    if (message.imu !== undefined) {
      obj.imu = IMUData.toJSON(message.imu);
    }
    if (message.imuCalibrate !== undefined) {
      obj.imuCalibrate = IMUCalibrateData.toJSON(message.imuCalibrate);
    }
    if (message.mode !== undefined) {
      obj.mode = ModeData.toJSON(message.mode);
    }
    if (message.input !== undefined) {
      obj.input = ControllerInputData.toJSON(message.input);
    }
    if (message.analytics !== undefined) {
      obj.analytics = AnalyticsData.toJSON(message.analytics);
    }
    if (message.angles !== undefined) {
      obj.angles = AnglesData.toJSON(message.angles);
    }
    if (message.i2cScan !== undefined) {
      obj.i2cScan = I2CScanData.toJSON(message.i2cScan);
    }
    if (message.peripheralSettings !== undefined) {
      obj.peripheralSettings = PeripheralSettingsData.toJSON(message.peripheralSettings);
    }
    if (message.wifiSettings !== undefined) {
      obj.wifiSettings = WifiSettingsData.toJSON(message.wifiSettings);
    }
    if (message.rssi !== undefined) {
      obj.rssi = RSSIData.toJSON(message.rssi);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<WebsocketMessage>, I>>(base?: I): WebsocketMessage {
    return WebsocketMessage.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<WebsocketMessage>, I>>(object: I): WebsocketMessage {
    const message = createBaseWebsocketMessage();
    message.subNotif = (object.subNotif !== undefined && object.subNotif !== null)
      ? SubscribeNotification.fromPartial(object.subNotif)
      : undefined;
    message.unsubNotif = (object.unsubNotif !== undefined && object.unsubNotif !== null)
      ? UnsubscribeNotification.fromPartial(object.unsubNotif)
      : undefined;
    message.pingmsg = (object.pingmsg !== undefined && object.pingmsg !== null)
      ? PingMsg.fromPartial(object.pingmsg)
      : undefined;
    message.pongmsg = (object.pongmsg !== undefined && object.pongmsg !== null)
      ? PongMsg.fromPartial(object.pongmsg)
      : undefined;
    message.imu = (object.imu !== undefined && object.imu !== null) ? IMUData.fromPartial(object.imu) : undefined;
    message.imuCalibrate = (object.imuCalibrate !== undefined && object.imuCalibrate !== null)
      ? IMUCalibrateData.fromPartial(object.imuCalibrate)
      : undefined;
    message.mode = (object.mode !== undefined && object.mode !== null) ? ModeData.fromPartial(object.mode) : undefined;
    message.input = (object.input !== undefined && object.input !== null)
      ? ControllerInputData.fromPartial(object.input)
      : undefined;
    message.analytics = (object.analytics !== undefined && object.analytics !== null)
      ? AnalyticsData.fromPartial(object.analytics)
      : undefined;
    message.angles = (object.angles !== undefined && object.angles !== null)
      ? AnglesData.fromPartial(object.angles)
      : undefined;
    message.i2cScan = (object.i2cScan !== undefined && object.i2cScan !== null)
      ? I2CScanData.fromPartial(object.i2cScan)
      : undefined;
    message.peripheralSettings = (object.peripheralSettings !== undefined && object.peripheralSettings !== null)
      ? PeripheralSettingsData.fromPartial(object.peripheralSettings)
      : undefined;
    message.wifiSettings = (object.wifiSettings !== undefined && object.wifiSettings !== null)
      ? WifiSettingsData.fromPartial(object.wifiSettings)
      : undefined;
    message.rssi = (object.rssi !== undefined && object.rssi !== null) ? RSSIData.fromPartial(object.rssi) : undefined;
    return message;
  },
};

type ProtoMetaMessageOptions = {
  options?: { [key: string]: any };
  fields?: { [key: string]: { [key: string]: any } };
  oneof?: { [key: string]: { [key: string]: any } };
  nested?: { [key: string]: ProtoMetaMessageOptions };
};

export interface ProtoMetadata {
  fileDescriptor: FileDescriptorProto;
  references: { [key: string]: any };
  dependencies?: ProtoMetadata[];
  options?: {
    options?: { [key: string]: any };
    services?: {
      [key: string]: { options?: { [key: string]: any }; methods?: { [key: string]: { [key: string]: any } } };
    };
    messages?: { [key: string]: ProtoMetaMessageOptions };
    enums?: { [key: string]: { options?: { [key: string]: any }; values?: { [key: string]: { [key: string]: any } } } };
  };
}

export const protoMetadata: ProtoMetadata = {
  fileDescriptor: {
    "name": "platform_shared/websocket_message.proto",
    "package": "",
    "dependency": [],
    "publicDependency": [],
    "weakDependency": [],
    "optionDependency": [],
    "messageType": [{
      "name": "Vector",
      "field": [{
        "name": "x",
        "number": 1,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "x",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "y",
        "number": 2,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "y",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "I2CDevice",
      "field": [{
        "name": "address",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "address",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "part_number",
        "number": 2,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "partNumber",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "name",
        "number": 3,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "name",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "PinConfig",
      "field": [{
        "name": "pin",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "pin",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "mode",
        "number": 2,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "mode",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "type",
        "number": 3,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "type",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "role",
        "number": 4,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "role",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "KnownNetworkItem",
      "field": [{
        "name": "ssid",
        "number": 1,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "ssid",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "password",
        "number": 2,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "password",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "static_ip",
        "number": 3,
        "label": 1,
        "type": 8,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "staticIp",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "local_ip",
        "number": 4,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "localIp",
        "options": undefined,
        "proto3Optional": true,
      }, {
        "name": "subnet_mask",
        "number": 5,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 1,
        "jsonName": "subnetMask",
        "options": undefined,
        "proto3Optional": true,
      }, {
        "name": "gateway_ip",
        "number": 6,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 2,
        "jsonName": "gatewayIp",
        "options": undefined,
        "proto3Optional": true,
      }, {
        "name": "dns_ip_1",
        "number": 7,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 3,
        "jsonName": "dnsIp1",
        "options": undefined,
        "proto3Optional": true,
      }, {
        "name": "dns_ip_2",
        "number": 8,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 4,
        "jsonName": "dnsIp2",
        "options": undefined,
        "proto3Optional": true,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [
        { "name": "_local_ip", "options": undefined },
        { "name": "_subnet_mask", "options": undefined },
        { "name": "_gateway_ip", "options": undefined },
        { "name": "_dns_ip_1", "options": undefined },
        { "name": "_dns_ip_2", "options": undefined },
      ],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "IMUData",
      "field": [{
        "name": "x",
        "number": 1,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "x",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "y",
        "number": 2,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "y",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "z",
        "number": 3,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "z",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "temp",
        "number": 4,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "temp",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "IMUCalibrateData",
      "field": [{
        "name": "success",
        "number": 1,
        "label": 1,
        "type": 8,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "success",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "ModeData",
      "field": [{
        "name": "mode",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "mode",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "ControllerInputData",
      "field": [{
        "name": "left",
        "number": 1,
        "label": 1,
        "type": 11,
        "typeName": ".Vector",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "left",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "right",
        "number": 2,
        "label": 1,
        "type": 11,
        "typeName": ".Vector",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "right",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "height",
        "number": 3,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "height",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "speed",
        "number": 4,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "speed",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "s1",
        "number": 5,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "s1",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "AnalyticsData",
      "field": [{
        "name": "max_alloc_heap",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "maxAllocHeap",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "psram_size",
        "number": 2,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "psramSize",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "free_psram",
        "number": 3,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "freePsram",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "free_heap",
        "number": 4,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "freeHeap",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "total_heap",
        "number": 5,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "totalHeap",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "min_free_heap",
        "number": 6,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "minFreeHeap",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "core_temp",
        "number": 7,
        "label": 1,
        "type": 2,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "coreTemp",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "fs_total",
        "number": 8,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "fsTotal",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "fs_used",
        "number": 9,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "fsUsed",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "uptime",
        "number": 10,
        "label": 1,
        "type": 3,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "uptime",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "cpu0_usage",
        "number": 11,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "cpu0Usage",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "cpu1_usage",
        "number": 12,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "cpu1Usage",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "cpu_usage",
        "number": 13,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "cpuUsage",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "AnglesData",
      "field": [{
        "name": "angles",
        "number": 1,
        "label": 3,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "angles",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "I2CScanData",
      "field": [{
        "name": "devices",
        "number": 1,
        "label": 3,
        "type": 11,
        "typeName": ".I2CDevice",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "devices",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "PeripheralSettingsData",
      "field": [{
        "name": "sda",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "sda",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "scl",
        "number": 2,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "scl",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "frequency",
        "number": 3,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "frequency",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "pins",
        "number": 4,
        "label": 3,
        "type": 11,
        "typeName": ".PinConfig",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "pins",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "WifiSettingsData",
      "field": [{
        "name": "hostname",
        "number": 1,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "hostname",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "priority_rssi",
        "number": 2,
        "label": 1,
        "type": 8,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "priorityRssi",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "wifi_networks",
        "number": 3,
        "label": 3,
        "type": 11,
        "typeName": ".KnownNetworkItem",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "wifiNetworks",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "RSSIData",
      "field": [{
        "name": "rssi",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "rssi",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "DownloadOTAData",
      "field": [{
        "name": "status",
        "number": 1,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "status",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "progress",
        "number": 2,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "progress",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "error",
        "number": 3,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "error",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "SonarData",
      "field": [{
        "name": "dummy_field",
        "number": 1,
        "label": 1,
        "type": 9,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "dummyField",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "SubscribeNotification",
      "field": [{
        "name": "tag",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "tag",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "UnsubscribeNotification",
      "field": [{
        "name": "tag",
        "number": 1,
        "label": 1,
        "type": 5,
        "typeName": "",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "tag",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "PingMsg",
      "field": [],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "PongMsg",
      "field": [],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }, {
      "name": "WebsocketMessage",
      "field": [{
        "name": "sub_notif",
        "number": 20,
        "label": 1,
        "type": 11,
        "typeName": ".SubscribeNotification",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "subNotif",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "unsub_notif",
        "number": 21,
        "label": 1,
        "type": 11,
        "typeName": ".UnsubscribeNotification",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "unsubNotif",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "pingmsg",
        "number": 30,
        "label": 1,
        "type": 11,
        "typeName": ".PingMsg",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "pingmsg",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "pongmsg",
        "number": 31,
        "label": 1,
        "type": 11,
        "typeName": ".PongMsg",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "pongmsg",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "imu",
        "number": 110,
        "label": 1,
        "type": 11,
        "typeName": ".IMUData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "imu",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "imu_calibrate",
        "number": 120,
        "label": 1,
        "type": 11,
        "typeName": ".IMUCalibrateData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "imuCalibrate",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "mode",
        "number": 130,
        "label": 1,
        "type": 11,
        "typeName": ".ModeData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "mode",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "input",
        "number": 140,
        "label": 1,
        "type": 11,
        "typeName": ".ControllerInputData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "input",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "analytics",
        "number": 150,
        "label": 1,
        "type": 11,
        "typeName": ".AnalyticsData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "analytics",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "angles",
        "number": 170,
        "label": 1,
        "type": 11,
        "typeName": ".AnglesData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "angles",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "i2c_scan",
        "number": 180,
        "label": 1,
        "type": 11,
        "typeName": ".I2CScanData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "i2cScan",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "peripheral_settings",
        "number": 190,
        "label": 1,
        "type": 11,
        "typeName": ".PeripheralSettingsData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "peripheralSettings",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "wifi_settings",
        "number": 240,
        "label": 1,
        "type": 11,
        "typeName": ".WifiSettingsData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "wifiSettings",
        "options": undefined,
        "proto3Optional": false,
      }, {
        "name": "rssi",
        "number": 260,
        "label": 1,
        "type": 11,
        "typeName": ".RSSIData",
        "extendee": "",
        "defaultValue": "",
        "oneofIndex": 0,
        "jsonName": "rssi",
        "options": undefined,
        "proto3Optional": false,
      }],
      "extension": [],
      "nestedType": [],
      "enumType": [],
      "extensionRange": [],
      "oneofDecl": [{ "name": "message", "options": undefined }],
      "options": undefined,
      "reservedRange": [],
      "reservedName": [],
      "visibility": 0,
    }],
    "enumType": [],
    "service": [],
    "extension": [],
    "options": undefined,
    "sourceCodeInfo": {
      "location": [{
        "path": [4, 4],
        "span": [8, 0, 13, 1],
        "leadingComments": " Individual message data types\n",
        "trailingComments": "",
        "leadingDetachedComments": [],
      }, {
        "path": [4, 20],
        "span": [56, 0, 73, 1],
        "leadingComments": " WebSocket message wrapper\n Only ONE field will be set at a time (oneof ensures this)\n",
        "trailingComments": "",
        "leadingDetachedComments": [],
      }],
    },
    "syntax": "proto3",
    "edition": 0,
  },
  references: {
    ".Vector": Vector,
    ".I2CDevice": I2CDevice,
    ".PinConfig": PinConfig,
    ".KnownNetworkItem": KnownNetworkItem,
    ".IMUData": IMUData,
    ".IMUCalibrateData": IMUCalibrateData,
    ".ModeData": ModeData,
    ".ControllerInputData": ControllerInputData,
    ".AnalyticsData": AnalyticsData,
    ".AnglesData": AnglesData,
    ".I2CScanData": I2CScanData,
    ".PeripheralSettingsData": PeripheralSettingsData,
    ".WifiSettingsData": WifiSettingsData,
    ".RSSIData": RSSIData,
    ".DownloadOTAData": DownloadOTAData,
    ".SonarData": SonarData,
    ".SubscribeNotification": SubscribeNotification,
    ".UnsubscribeNotification": UnsubscribeNotification,
    ".PingMsg": PingMsg,
    ".PongMsg": PongMsg,
    ".WebsocketMessage": WebsocketMessage,
  },
  dependencies: [],
};

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

export type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.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]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

function longToNumber(int64: { toString(): string }): number {
  const num = globalThis.Number(int64.toString());
  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
  }
  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
  }
  return num;
}

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}