mavsdk-types 1.0.0

package/telemetry_server/telemetry_server_pb.d.ts

@@ -0,0 +1,1562 @@
+import * as jspb from 'google-protobuf'
+
+import * as mavsdk_options_pb from '../mavsdk_options_pb';
+
+
+export class PublishPositionRequest extends jspb.Message {
+  getPosition(): Position | undefined;
+  setPosition(value?: Position): PublishPositionRequest;
+  hasPosition(): boolean;
+  clearPosition(): PublishPositionRequest;
+
+  getVelocityNed(): VelocityNed | undefined;
+  setVelocityNed(value?: VelocityNed): PublishPositionRequest;
+  hasVelocityNed(): boolean;
+  clearVelocityNed(): PublishPositionRequest;
+
+  getHeading(): Heading | undefined;
+  setHeading(value?: Heading): PublishPositionRequest;
+  hasHeading(): boolean;
+  clearHeading(): PublishPositionRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishPositionRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishPositionRequest): PublishPositionRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishPositionRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishPositionRequest;
+  static deserializeBinaryFromReader(message: PublishPositionRequest, reader: jspb.BinaryReader): PublishPositionRequest;
+}
+
+export namespace PublishPositionRequest {
+  export type AsObject = {
+    position?: Position.AsObject,
+    velocityNed?: VelocityNed.AsObject,
+    heading?: Heading.AsObject,
+  }
+}
+
+export class PublishHomeRequest extends jspb.Message {
+  getHome(): Position | undefined;
+  setHome(value?: Position): PublishHomeRequest;
+  hasHome(): boolean;
+  clearHome(): PublishHomeRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishHomeRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishHomeRequest): PublishHomeRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishHomeRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishHomeRequest;
+  static deserializeBinaryFromReader(message: PublishHomeRequest, reader: jspb.BinaryReader): PublishHomeRequest;
+}
+
+export namespace PublishHomeRequest {
+  export type AsObject = {
+    home?: Position.AsObject,
+  }
+}
+
+export class PublishSysStatusRequest extends jspb.Message {
+  getBattery(): Battery | undefined;
+  setBattery(value?: Battery): PublishSysStatusRequest;
+  hasBattery(): boolean;
+  clearBattery(): PublishSysStatusRequest;
+
+  getRcReceiverStatus(): boolean;
+  setRcReceiverStatus(value: boolean): PublishSysStatusRequest;
+
+  getGyroStatus(): boolean;
+  setGyroStatus(value: boolean): PublishSysStatusRequest;
+
+  getAccelStatus(): boolean;
+  setAccelStatus(value: boolean): PublishSysStatusRequest;
+
+  getMagStatus(): boolean;
+  setMagStatus(value: boolean): PublishSysStatusRequest;
+
+  getGpsStatus(): boolean;
+  setGpsStatus(value: boolean): PublishSysStatusRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishSysStatusRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishSysStatusRequest): PublishSysStatusRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishSysStatusRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishSysStatusRequest;
+  static deserializeBinaryFromReader(message: PublishSysStatusRequest, reader: jspb.BinaryReader): PublishSysStatusRequest;
+}
+
+export namespace PublishSysStatusRequest {
+  export type AsObject = {
+    battery?: Battery.AsObject,
+    rcReceiverStatus: boolean,
+    gyroStatus: boolean,
+    accelStatus: boolean,
+    magStatus: boolean,
+    gpsStatus: boolean,
+  }
+}
+
+export class PublishExtendedSysStateRequest extends jspb.Message {
+  getVtolState(): VtolState;
+  setVtolState(value: VtolState): PublishExtendedSysStateRequest;
+
+  getLandedState(): LandedState;
+  setLandedState(value: LandedState): PublishExtendedSysStateRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishExtendedSysStateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishExtendedSysStateRequest): PublishExtendedSysStateRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishExtendedSysStateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishExtendedSysStateRequest;
+  static deserializeBinaryFromReader(message: PublishExtendedSysStateRequest, reader: jspb.BinaryReader): PublishExtendedSysStateRequest;
+}
+
+export namespace PublishExtendedSysStateRequest {
+  export type AsObject = {
+    vtolState: VtolState,
+    landedState: LandedState,
+  }
+}
+
+export class PublishInAirRequest extends jspb.Message {
+  getIsInAir(): boolean;
+  setIsInAir(value: boolean): PublishInAirRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishInAirRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishInAirRequest): PublishInAirRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishInAirRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishInAirRequest;
+  static deserializeBinaryFromReader(message: PublishInAirRequest, reader: jspb.BinaryReader): PublishInAirRequest;
+}
+
+export namespace PublishInAirRequest {
+  export type AsObject = {
+    isInAir: boolean,
+  }
+}
+
+export class PublishLandedStateRequest extends jspb.Message {
+  getLandedState(): LandedState;
+  setLandedState(value: LandedState): PublishLandedStateRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishLandedStateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishLandedStateRequest): PublishLandedStateRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishLandedStateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishLandedStateRequest;
+  static deserializeBinaryFromReader(message: PublishLandedStateRequest, reader: jspb.BinaryReader): PublishLandedStateRequest;
+}
+
+export namespace PublishLandedStateRequest {
+  export type AsObject = {
+    landedState: LandedState,
+  }
+}
+
+export class PublishRawGpsRequest extends jspb.Message {
+  getRawGps(): RawGps | undefined;
+  setRawGps(value?: RawGps): PublishRawGpsRequest;
+  hasRawGps(): boolean;
+  clearRawGps(): PublishRawGpsRequest;
+
+  getGpsInfo(): GpsInfo | undefined;
+  setGpsInfo(value?: GpsInfo): PublishRawGpsRequest;
+  hasGpsInfo(): boolean;
+  clearGpsInfo(): PublishRawGpsRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishRawGpsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishRawGpsRequest): PublishRawGpsRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishRawGpsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishRawGpsRequest;
+  static deserializeBinaryFromReader(message: PublishRawGpsRequest, reader: jspb.BinaryReader): PublishRawGpsRequest;
+}
+
+export namespace PublishRawGpsRequest {
+  export type AsObject = {
+    rawGps?: RawGps.AsObject,
+    gpsInfo?: GpsInfo.AsObject,
+  }
+}
+
+export class PublishBatteryRequest extends jspb.Message {
+  getBattery(): Battery | undefined;
+  setBattery(value?: Battery): PublishBatteryRequest;
+  hasBattery(): boolean;
+  clearBattery(): PublishBatteryRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishBatteryRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishBatteryRequest): PublishBatteryRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishBatteryRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishBatteryRequest;
+  static deserializeBinaryFromReader(message: PublishBatteryRequest, reader: jspb.BinaryReader): PublishBatteryRequest;
+}
+
+export namespace PublishBatteryRequest {
+  export type AsObject = {
+    battery?: Battery.AsObject,
+  }
+}
+
+export class PublishRcStatusRequest extends jspb.Message {
+  getRcStatus(): RcStatus | undefined;
+  setRcStatus(value?: RcStatus): PublishRcStatusRequest;
+  hasRcStatus(): boolean;
+  clearRcStatus(): PublishRcStatusRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishRcStatusRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishRcStatusRequest): PublishRcStatusRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishRcStatusRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishRcStatusRequest;
+  static deserializeBinaryFromReader(message: PublishRcStatusRequest, reader: jspb.BinaryReader): PublishRcStatusRequest;
+}
+
+export namespace PublishRcStatusRequest {
+  export type AsObject = {
+    rcStatus?: RcStatus.AsObject,
+  }
+}
+
+export class PublishStatusTextRequest extends jspb.Message {
+  getStatusText(): StatusText | undefined;
+  setStatusText(value?: StatusText): PublishStatusTextRequest;
+  hasStatusText(): boolean;
+  clearStatusText(): PublishStatusTextRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishStatusTextRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishStatusTextRequest): PublishStatusTextRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishStatusTextRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishStatusTextRequest;
+  static deserializeBinaryFromReader(message: PublishStatusTextRequest, reader: jspb.BinaryReader): PublishStatusTextRequest;
+}
+
+export namespace PublishStatusTextRequest {
+  export type AsObject = {
+    statusText?: StatusText.AsObject,
+  }
+}
+
+export class PublishOdometryRequest extends jspb.Message {
+  getOdometry(): Odometry | undefined;
+  setOdometry(value?: Odometry): PublishOdometryRequest;
+  hasOdometry(): boolean;
+  clearOdometry(): PublishOdometryRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishOdometryRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishOdometryRequest): PublishOdometryRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishOdometryRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishOdometryRequest;
+  static deserializeBinaryFromReader(message: PublishOdometryRequest, reader: jspb.BinaryReader): PublishOdometryRequest;
+}
+
+export namespace PublishOdometryRequest {
+  export type AsObject = {
+    odometry?: Odometry.AsObject,
+  }
+}
+
+export class PublishPositionVelocityNedRequest extends jspb.Message {
+  getPositionVelocityNed(): PositionVelocityNed | undefined;
+  setPositionVelocityNed(value?: PositionVelocityNed): PublishPositionVelocityNedRequest;
+  hasPositionVelocityNed(): boolean;
+  clearPositionVelocityNed(): PublishPositionVelocityNedRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishPositionVelocityNedRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishPositionVelocityNedRequest): PublishPositionVelocityNedRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishPositionVelocityNedRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishPositionVelocityNedRequest;
+  static deserializeBinaryFromReader(message: PublishPositionVelocityNedRequest, reader: jspb.BinaryReader): PublishPositionVelocityNedRequest;
+}
+
+export namespace PublishPositionVelocityNedRequest {
+  export type AsObject = {
+    positionVelocityNed?: PositionVelocityNed.AsObject,
+  }
+}
+
+export class PublishGroundTruthRequest extends jspb.Message {
+  getGroundTruth(): GroundTruth | undefined;
+  setGroundTruth(value?: GroundTruth): PublishGroundTruthRequest;
+  hasGroundTruth(): boolean;
+  clearGroundTruth(): PublishGroundTruthRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishGroundTruthRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishGroundTruthRequest): PublishGroundTruthRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishGroundTruthRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishGroundTruthRequest;
+  static deserializeBinaryFromReader(message: PublishGroundTruthRequest, reader: jspb.BinaryReader): PublishGroundTruthRequest;
+}
+
+export namespace PublishGroundTruthRequest {
+  export type AsObject = {
+    groundTruth?: GroundTruth.AsObject,
+  }
+}
+
+export class PublishImuRequest extends jspb.Message {
+  getImu(): Imu | undefined;
+  setImu(value?: Imu): PublishImuRequest;
+  hasImu(): boolean;
+  clearImu(): PublishImuRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishImuRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishImuRequest): PublishImuRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishImuRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishImuRequest;
+  static deserializeBinaryFromReader(message: PublishImuRequest, reader: jspb.BinaryReader): PublishImuRequest;
+}
+
+export namespace PublishImuRequest {
+  export type AsObject = {
+    imu?: Imu.AsObject,
+  }
+}
+
+export class PublishScaledImuRequest extends jspb.Message {
+  getImu(): Imu | undefined;
+  setImu(value?: Imu): PublishScaledImuRequest;
+  hasImu(): boolean;
+  clearImu(): PublishScaledImuRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishScaledImuRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishScaledImuRequest): PublishScaledImuRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishScaledImuRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishScaledImuRequest;
+  static deserializeBinaryFromReader(message: PublishScaledImuRequest, reader: jspb.BinaryReader): PublishScaledImuRequest;
+}
+
+export namespace PublishScaledImuRequest {
+  export type AsObject = {
+    imu?: Imu.AsObject,
+  }
+}
+
+export class PublishRawImuRequest extends jspb.Message {
+  getImu(): Imu | undefined;
+  setImu(value?: Imu): PublishRawImuRequest;
+  hasImu(): boolean;
+  clearImu(): PublishRawImuRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishRawImuRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishRawImuRequest): PublishRawImuRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishRawImuRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishRawImuRequest;
+  static deserializeBinaryFromReader(message: PublishRawImuRequest, reader: jspb.BinaryReader): PublishRawImuRequest;
+}
+
+export namespace PublishRawImuRequest {
+  export type AsObject = {
+    imu?: Imu.AsObject,
+  }
+}
+
+export class PublishUnixEpochTimeRequest extends jspb.Message {
+  getTimeUs(): number;
+  setTimeUs(value: number): PublishUnixEpochTimeRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishUnixEpochTimeRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishUnixEpochTimeRequest): PublishUnixEpochTimeRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishUnixEpochTimeRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishUnixEpochTimeRequest;
+  static deserializeBinaryFromReader(message: PublishUnixEpochTimeRequest, reader: jspb.BinaryReader): PublishUnixEpochTimeRequest;
+}
+
+export namespace PublishUnixEpochTimeRequest {
+  export type AsObject = {
+    timeUs: number,
+  }
+}
+
+export class PublishDistanceSensorRequest extends jspb.Message {
+  getDistanceSensor(): DistanceSensor | undefined;
+  setDistanceSensor(value?: DistanceSensor): PublishDistanceSensorRequest;
+  hasDistanceSensor(): boolean;
+  clearDistanceSensor(): PublishDistanceSensorRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishDistanceSensorRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishDistanceSensorRequest): PublishDistanceSensorRequest.AsObject;
+  static serializeBinaryToWriter(message: PublishDistanceSensorRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishDistanceSensorRequest;
+  static deserializeBinaryFromReader(message: PublishDistanceSensorRequest, reader: jspb.BinaryReader): PublishDistanceSensorRequest;
+}
+
+export namespace PublishDistanceSensorRequest {
+  export type AsObject = {
+    distanceSensor?: DistanceSensor.AsObject,
+  }
+}
+
+export class PublishPositionResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishPositionResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishPositionResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishPositionResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishPositionResponse): PublishPositionResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishPositionResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishPositionResponse;
+  static deserializeBinaryFromReader(message: PublishPositionResponse, reader: jspb.BinaryReader): PublishPositionResponse;
+}
+
+export namespace PublishPositionResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishHomeResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishHomeResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishHomeResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishHomeResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishHomeResponse): PublishHomeResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishHomeResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishHomeResponse;
+  static deserializeBinaryFromReader(message: PublishHomeResponse, reader: jspb.BinaryReader): PublishHomeResponse;
+}
+
+export namespace PublishHomeResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishSysStatusResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishSysStatusResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishSysStatusResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishSysStatusResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishSysStatusResponse): PublishSysStatusResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishSysStatusResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishSysStatusResponse;
+  static deserializeBinaryFromReader(message: PublishSysStatusResponse, reader: jspb.BinaryReader): PublishSysStatusResponse;
+}
+
+export namespace PublishSysStatusResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishExtendedSysStateResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishExtendedSysStateResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishExtendedSysStateResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishExtendedSysStateResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishExtendedSysStateResponse): PublishExtendedSysStateResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishExtendedSysStateResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishExtendedSysStateResponse;
+  static deserializeBinaryFromReader(message: PublishExtendedSysStateResponse, reader: jspb.BinaryReader): PublishExtendedSysStateResponse;
+}
+
+export namespace PublishExtendedSysStateResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishRawGpsResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishRawGpsResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishRawGpsResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishRawGpsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishRawGpsResponse): PublishRawGpsResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishRawGpsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishRawGpsResponse;
+  static deserializeBinaryFromReader(message: PublishRawGpsResponse, reader: jspb.BinaryReader): PublishRawGpsResponse;
+}
+
+export namespace PublishRawGpsResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishBatteryResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishBatteryResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishBatteryResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishBatteryResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishBatteryResponse): PublishBatteryResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishBatteryResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishBatteryResponse;
+  static deserializeBinaryFromReader(message: PublishBatteryResponse, reader: jspb.BinaryReader): PublishBatteryResponse;
+}
+
+export namespace PublishBatteryResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishStatusTextResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishStatusTextResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishStatusTextResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishStatusTextResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishStatusTextResponse): PublishStatusTextResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishStatusTextResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishStatusTextResponse;
+  static deserializeBinaryFromReader(message: PublishStatusTextResponse, reader: jspb.BinaryReader): PublishStatusTextResponse;
+}
+
+export namespace PublishStatusTextResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishOdometryResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishOdometryResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishOdometryResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishOdometryResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishOdometryResponse): PublishOdometryResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishOdometryResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishOdometryResponse;
+  static deserializeBinaryFromReader(message: PublishOdometryResponse, reader: jspb.BinaryReader): PublishOdometryResponse;
+}
+
+export namespace PublishOdometryResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishPositionVelocityNedResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishPositionVelocityNedResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishPositionVelocityNedResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishPositionVelocityNedResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishPositionVelocityNedResponse): PublishPositionVelocityNedResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishPositionVelocityNedResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishPositionVelocityNedResponse;
+  static deserializeBinaryFromReader(message: PublishPositionVelocityNedResponse, reader: jspb.BinaryReader): PublishPositionVelocityNedResponse;
+}
+
+export namespace PublishPositionVelocityNedResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishGroundTruthResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishGroundTruthResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishGroundTruthResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishGroundTruthResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishGroundTruthResponse): PublishGroundTruthResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishGroundTruthResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishGroundTruthResponse;
+  static deserializeBinaryFromReader(message: PublishGroundTruthResponse, reader: jspb.BinaryReader): PublishGroundTruthResponse;
+}
+
+export namespace PublishGroundTruthResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishImuResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishImuResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishImuResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishImuResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishImuResponse): PublishImuResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishImuResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishImuResponse;
+  static deserializeBinaryFromReader(message: PublishImuResponse, reader: jspb.BinaryReader): PublishImuResponse;
+}
+
+export namespace PublishImuResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishScaledImuResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishScaledImuResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishScaledImuResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishScaledImuResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishScaledImuResponse): PublishScaledImuResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishScaledImuResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishScaledImuResponse;
+  static deserializeBinaryFromReader(message: PublishScaledImuResponse, reader: jspb.BinaryReader): PublishScaledImuResponse;
+}
+
+export namespace PublishScaledImuResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishRawImuResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishRawImuResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishRawImuResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishRawImuResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishRawImuResponse): PublishRawImuResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishRawImuResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishRawImuResponse;
+  static deserializeBinaryFromReader(message: PublishRawImuResponse, reader: jspb.BinaryReader): PublishRawImuResponse;
+}
+
+export namespace PublishRawImuResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishUnixEpochTimeResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishUnixEpochTimeResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishUnixEpochTimeResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishUnixEpochTimeResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishUnixEpochTimeResponse): PublishUnixEpochTimeResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishUnixEpochTimeResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishUnixEpochTimeResponse;
+  static deserializeBinaryFromReader(message: PublishUnixEpochTimeResponse, reader: jspb.BinaryReader): PublishUnixEpochTimeResponse;
+}
+
+export namespace PublishUnixEpochTimeResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class PublishDistanceSensorResponse extends jspb.Message {
+  getTelemetryServerResult(): TelemetryServerResult | undefined;
+  setTelemetryServerResult(value?: TelemetryServerResult): PublishDistanceSensorResponse;
+  hasTelemetryServerResult(): boolean;
+  clearTelemetryServerResult(): PublishDistanceSensorResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PublishDistanceSensorResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PublishDistanceSensorResponse): PublishDistanceSensorResponse.AsObject;
+  static serializeBinaryToWriter(message: PublishDistanceSensorResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PublishDistanceSensorResponse;
+  static deserializeBinaryFromReader(message: PublishDistanceSensorResponse, reader: jspb.BinaryReader): PublishDistanceSensorResponse;
+}
+
+export namespace PublishDistanceSensorResponse {
+  export type AsObject = {
+    telemetryServerResult?: TelemetryServerResult.AsObject,
+  }
+}
+
+export class Position extends jspb.Message {
+  getLatitudeDeg(): number;
+  setLatitudeDeg(value: number): Position;
+
+  getLongitudeDeg(): number;
+  setLongitudeDeg(value: number): Position;
+
+  getAbsoluteAltitudeM(): number;
+  setAbsoluteAltitudeM(value: number): Position;
+
+  getRelativeAltitudeM(): number;
+  setRelativeAltitudeM(value: number): Position;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Position.AsObject;
+  static toObject(includeInstance: boolean, msg: Position): Position.AsObject;
+  static serializeBinaryToWriter(message: Position, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Position;
+  static deserializeBinaryFromReader(message: Position, reader: jspb.BinaryReader): Position;
+}
+
+export namespace Position {
+  export type AsObject = {
+    latitudeDeg: number,
+    longitudeDeg: number,
+    absoluteAltitudeM: number,
+    relativeAltitudeM: number,
+  }
+}
+
+export class Heading extends jspb.Message {
+  getHeadingDeg(): number;
+  setHeadingDeg(value: number): Heading;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Heading.AsObject;
+  static toObject(includeInstance: boolean, msg: Heading): Heading.AsObject;
+  static serializeBinaryToWriter(message: Heading, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Heading;
+  static deserializeBinaryFromReader(message: Heading, reader: jspb.BinaryReader): Heading;
+}
+
+export namespace Heading {
+  export type AsObject = {
+    headingDeg: number,
+  }
+}
+
+export class Quaternion extends jspb.Message {
+  getW(): number;
+  setW(value: number): Quaternion;
+
+  getX(): number;
+  setX(value: number): Quaternion;
+
+  getY(): number;
+  setY(value: number): Quaternion;
+
+  getZ(): number;
+  setZ(value: number): Quaternion;
+
+  getTimestampUs(): number;
+  setTimestampUs(value: number): Quaternion;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Quaternion.AsObject;
+  static toObject(includeInstance: boolean, msg: Quaternion): Quaternion.AsObject;
+  static serializeBinaryToWriter(message: Quaternion, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Quaternion;
+  static deserializeBinaryFromReader(message: Quaternion, reader: jspb.BinaryReader): Quaternion;
+}
+
+export namespace Quaternion {
+  export type AsObject = {
+    w: number,
+    x: number,
+    y: number,
+    z: number,
+    timestampUs: number,
+  }
+}
+
+export class EulerAngle extends jspb.Message {
+  getRollDeg(): number;
+  setRollDeg(value: number): EulerAngle;
+
+  getPitchDeg(): number;
+  setPitchDeg(value: number): EulerAngle;
+
+  getYawDeg(): number;
+  setYawDeg(value: number): EulerAngle;
+
+  getTimestampUs(): number;
+  setTimestampUs(value: number): EulerAngle;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): EulerAngle.AsObject;
+  static toObject(includeInstance: boolean, msg: EulerAngle): EulerAngle.AsObject;
+  static serializeBinaryToWriter(message: EulerAngle, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): EulerAngle;
+  static deserializeBinaryFromReader(message: EulerAngle, reader: jspb.BinaryReader): EulerAngle;
+}
+
+export namespace EulerAngle {
+  export type AsObject = {
+    rollDeg: number,
+    pitchDeg: number,
+    yawDeg: number,
+    timestampUs: number,
+  }
+}
+
+export class AngularVelocityBody extends jspb.Message {
+  getRollRadS(): number;
+  setRollRadS(value: number): AngularVelocityBody;
+
+  getPitchRadS(): number;
+  setPitchRadS(value: number): AngularVelocityBody;
+
+  getYawRadS(): number;
+  setYawRadS(value: number): AngularVelocityBody;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AngularVelocityBody.AsObject;
+  static toObject(includeInstance: boolean, msg: AngularVelocityBody): AngularVelocityBody.AsObject;
+  static serializeBinaryToWriter(message: AngularVelocityBody, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AngularVelocityBody;
+  static deserializeBinaryFromReader(message: AngularVelocityBody, reader: jspb.BinaryReader): AngularVelocityBody;
+}
+
+export namespace AngularVelocityBody {
+  export type AsObject = {
+    rollRadS: number,
+    pitchRadS: number,
+    yawRadS: number,
+  }
+}
+
+export class GpsInfo extends jspb.Message {
+  getNumSatellites(): number;
+  setNumSatellites(value: number): GpsInfo;
+
+  getFixType(): FixType;
+  setFixType(value: FixType): GpsInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GpsInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: GpsInfo): GpsInfo.AsObject;
+  static serializeBinaryToWriter(message: GpsInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GpsInfo;
+  static deserializeBinaryFromReader(message: GpsInfo, reader: jspb.BinaryReader): GpsInfo;
+}
+
+export namespace GpsInfo {
+  export type AsObject = {
+    numSatellites: number,
+    fixType: FixType,
+  }
+}
+
+export class RawGps extends jspb.Message {
+  getTimestampUs(): number;
+  setTimestampUs(value: number): RawGps;
+
+  getLatitudeDeg(): number;
+  setLatitudeDeg(value: number): RawGps;
+
+  getLongitudeDeg(): number;
+  setLongitudeDeg(value: number): RawGps;
+
+  getAbsoluteAltitudeM(): number;
+  setAbsoluteAltitudeM(value: number): RawGps;
+
+  getHdop(): number;
+  setHdop(value: number): RawGps;
+
+  getVdop(): number;
+  setVdop(value: number): RawGps;
+
+  getVelocityMS(): number;
+  setVelocityMS(value: number): RawGps;
+
+  getCogDeg(): number;
+  setCogDeg(value: number): RawGps;
+
+  getAltitudeEllipsoidM(): number;
+  setAltitudeEllipsoidM(value: number): RawGps;
+
+  getHorizontalUncertaintyM(): number;
+  setHorizontalUncertaintyM(value: number): RawGps;
+
+  getVerticalUncertaintyM(): number;
+  setVerticalUncertaintyM(value: number): RawGps;
+
+  getVelocityUncertaintyMS(): number;
+  setVelocityUncertaintyMS(value: number): RawGps;
+
+  getHeadingUncertaintyDeg(): number;
+  setHeadingUncertaintyDeg(value: number): RawGps;
+
+  getYawDeg(): number;
+  setYawDeg(value: number): RawGps;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RawGps.AsObject;
+  static toObject(includeInstance: boolean, msg: RawGps): RawGps.AsObject;
+  static serializeBinaryToWriter(message: RawGps, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RawGps;
+  static deserializeBinaryFromReader(message: RawGps, reader: jspb.BinaryReader): RawGps;
+}
+
+export namespace RawGps {
+  export type AsObject = {
+    timestampUs: number,
+    latitudeDeg: number,
+    longitudeDeg: number,
+    absoluteAltitudeM: number,
+    hdop: number,
+    vdop: number,
+    velocityMS: number,
+    cogDeg: number,
+    altitudeEllipsoidM: number,
+    horizontalUncertaintyM: number,
+    verticalUncertaintyM: number,
+    velocityUncertaintyMS: number,
+    headingUncertaintyDeg: number,
+    yawDeg: number,
+  }
+}
+
+export class Battery extends jspb.Message {
+  getVoltageV(): number;
+  setVoltageV(value: number): Battery;
+
+  getRemainingPercent(): number;
+  setRemainingPercent(value: number): Battery;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Battery.AsObject;
+  static toObject(includeInstance: boolean, msg: Battery): Battery.AsObject;
+  static serializeBinaryToWriter(message: Battery, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Battery;
+  static deserializeBinaryFromReader(message: Battery, reader: jspb.BinaryReader): Battery;
+}
+
+export namespace Battery {
+  export type AsObject = {
+    voltageV: number,
+    remainingPercent: number,
+  }
+}
+
+export class RcStatus extends jspb.Message {
+  getWasAvailableOnce(): boolean;
+  setWasAvailableOnce(value: boolean): RcStatus;
+
+  getIsAvailable(): boolean;
+  setIsAvailable(value: boolean): RcStatus;
+
+  getSignalStrengthPercent(): number;
+  setSignalStrengthPercent(value: number): RcStatus;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RcStatus.AsObject;
+  static toObject(includeInstance: boolean, msg: RcStatus): RcStatus.AsObject;
+  static serializeBinaryToWriter(message: RcStatus, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RcStatus;
+  static deserializeBinaryFromReader(message: RcStatus, reader: jspb.BinaryReader): RcStatus;
+}
+
+export namespace RcStatus {
+  export type AsObject = {
+    wasAvailableOnce: boolean,
+    isAvailable: boolean,
+    signalStrengthPercent: number,
+  }
+}
+
+export class StatusText extends jspb.Message {
+  getType(): StatusTextType;
+  setType(value: StatusTextType): StatusText;
+
+  getText(): string;
+  setText(value: string): StatusText;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StatusText.AsObject;
+  static toObject(includeInstance: boolean, msg: StatusText): StatusText.AsObject;
+  static serializeBinaryToWriter(message: StatusText, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StatusText;
+  static deserializeBinaryFromReader(message: StatusText, reader: jspb.BinaryReader): StatusText;
+}
+
+export namespace StatusText {
+  export type AsObject = {
+    type: StatusTextType,
+    text: string,
+  }
+}
+
+export class ActuatorControlTarget extends jspb.Message {
+  getGroup(): number;
+  setGroup(value: number): ActuatorControlTarget;
+
+  getControlsList(): Array<number>;
+  setControlsList(value: Array<number>): ActuatorControlTarget;
+  clearControlsList(): ActuatorControlTarget;
+  addControls(value: number, index?: number): ActuatorControlTarget;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ActuatorControlTarget.AsObject;
+  static toObject(includeInstance: boolean, msg: ActuatorControlTarget): ActuatorControlTarget.AsObject;
+  static serializeBinaryToWriter(message: ActuatorControlTarget, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ActuatorControlTarget;
+  static deserializeBinaryFromReader(message: ActuatorControlTarget, reader: jspb.BinaryReader): ActuatorControlTarget;
+}
+
+export namespace ActuatorControlTarget {
+  export type AsObject = {
+    group: number,
+    controlsList: Array<number>,
+  }
+}
+
+export class ActuatorOutputStatus extends jspb.Message {
+  getActive(): number;
+  setActive(value: number): ActuatorOutputStatus;
+
+  getActuatorList(): Array<number>;
+  setActuatorList(value: Array<number>): ActuatorOutputStatus;
+  clearActuatorList(): ActuatorOutputStatus;
+  addActuator(value: number, index?: number): ActuatorOutputStatus;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ActuatorOutputStatus.AsObject;
+  static toObject(includeInstance: boolean, msg: ActuatorOutputStatus): ActuatorOutputStatus.AsObject;
+  static serializeBinaryToWriter(message: ActuatorOutputStatus, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ActuatorOutputStatus;
+  static deserializeBinaryFromReader(message: ActuatorOutputStatus, reader: jspb.BinaryReader): ActuatorOutputStatus;
+}
+
+export namespace ActuatorOutputStatus {
+  export type AsObject = {
+    active: number,
+    actuatorList: Array<number>,
+  }
+}
+
+export class Covariance extends jspb.Message {
+  getCovarianceMatrixList(): Array<number>;
+  setCovarianceMatrixList(value: Array<number>): Covariance;
+  clearCovarianceMatrixList(): Covariance;
+  addCovarianceMatrix(value: number, index?: number): Covariance;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Covariance.AsObject;
+  static toObject(includeInstance: boolean, msg: Covariance): Covariance.AsObject;
+  static serializeBinaryToWriter(message: Covariance, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Covariance;
+  static deserializeBinaryFromReader(message: Covariance, reader: jspb.BinaryReader): Covariance;
+}
+
+export namespace Covariance {
+  export type AsObject = {
+    covarianceMatrixList: Array<number>,
+  }
+}
+
+export class VelocityBody extends jspb.Message {
+  getXMS(): number;
+  setXMS(value: number): VelocityBody;
+
+  getYMS(): number;
+  setYMS(value: number): VelocityBody;
+
+  getZMS(): number;
+  setZMS(value: number): VelocityBody;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): VelocityBody.AsObject;
+  static toObject(includeInstance: boolean, msg: VelocityBody): VelocityBody.AsObject;
+  static serializeBinaryToWriter(message: VelocityBody, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): VelocityBody;
+  static deserializeBinaryFromReader(message: VelocityBody, reader: jspb.BinaryReader): VelocityBody;
+}
+
+export namespace VelocityBody {
+  export type AsObject = {
+    xMS: number,
+    yMS: number,
+    zMS: number,
+  }
+}
+
+export class PositionBody extends jspb.Message {
+  getXM(): number;
+  setXM(value: number): PositionBody;
+
+  getYM(): number;
+  setYM(value: number): PositionBody;
+
+  getZM(): number;
+  setZM(value: number): PositionBody;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PositionBody.AsObject;
+  static toObject(includeInstance: boolean, msg: PositionBody): PositionBody.AsObject;
+  static serializeBinaryToWriter(message: PositionBody, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PositionBody;
+  static deserializeBinaryFromReader(message: PositionBody, reader: jspb.BinaryReader): PositionBody;
+}
+
+export namespace PositionBody {
+  export type AsObject = {
+    xM: number,
+    yM: number,
+    zM: number,
+  }
+}
+
+export class Odometry extends jspb.Message {
+  getTimeUsec(): number;
+  setTimeUsec(value: number): Odometry;
+
+  getFrameId(): Odometry.MavFrame;
+  setFrameId(value: Odometry.MavFrame): Odometry;
+
+  getChildFrameId(): Odometry.MavFrame;
+  setChildFrameId(value: Odometry.MavFrame): Odometry;
+
+  getPositionBody(): PositionBody | undefined;
+  setPositionBody(value?: PositionBody): Odometry;
+  hasPositionBody(): boolean;
+  clearPositionBody(): Odometry;
+
+  getQ(): Quaternion | undefined;
+  setQ(value?: Quaternion): Odometry;
+  hasQ(): boolean;
+  clearQ(): Odometry;
+
+  getVelocityBody(): VelocityBody | undefined;
+  setVelocityBody(value?: VelocityBody): Odometry;
+  hasVelocityBody(): boolean;
+  clearVelocityBody(): Odometry;
+
+  getAngularVelocityBody(): AngularVelocityBody | undefined;
+  setAngularVelocityBody(value?: AngularVelocityBody): Odometry;
+  hasAngularVelocityBody(): boolean;
+  clearAngularVelocityBody(): Odometry;
+
+  getPoseCovariance(): Covariance | undefined;
+  setPoseCovariance(value?: Covariance): Odometry;
+  hasPoseCovariance(): boolean;
+  clearPoseCovariance(): Odometry;
+
+  getVelocityCovariance(): Covariance | undefined;
+  setVelocityCovariance(value?: Covariance): Odometry;
+  hasVelocityCovariance(): boolean;
+  clearVelocityCovariance(): Odometry;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Odometry.AsObject;
+  static toObject(includeInstance: boolean, msg: Odometry): Odometry.AsObject;
+  static serializeBinaryToWriter(message: Odometry, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Odometry;
+  static deserializeBinaryFromReader(message: Odometry, reader: jspb.BinaryReader): Odometry;
+}
+
+export namespace Odometry {
+  export type AsObject = {
+    timeUsec: number,
+    frameId: Odometry.MavFrame,
+    childFrameId: Odometry.MavFrame,
+    positionBody?: PositionBody.AsObject,
+    q?: Quaternion.AsObject,
+    velocityBody?: VelocityBody.AsObject,
+    angularVelocityBody?: AngularVelocityBody.AsObject,
+    poseCovariance?: Covariance.AsObject,
+    velocityCovariance?: Covariance.AsObject,
+  }
+
+  export enum MavFrame { 
+    MAV_FRAME_UNDEF = 0,
+    MAV_FRAME_BODY_NED = 8,
+    MAV_FRAME_VISION_NED = 16,
+    MAV_FRAME_ESTIM_NED = 18,
+  }
+}
+
+export class DistanceSensor extends jspb.Message {
+  getMinimumDistanceM(): number;
+  setMinimumDistanceM(value: number): DistanceSensor;
+
+  getMaximumDistanceM(): number;
+  setMaximumDistanceM(value: number): DistanceSensor;
+
+  getCurrentDistanceM(): number;
+  setCurrentDistanceM(value: number): DistanceSensor;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DistanceSensor.AsObject;
+  static toObject(includeInstance: boolean, msg: DistanceSensor): DistanceSensor.AsObject;
+  static serializeBinaryToWriter(message: DistanceSensor, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DistanceSensor;
+  static deserializeBinaryFromReader(message: DistanceSensor, reader: jspb.BinaryReader): DistanceSensor;
+}
+
+export namespace DistanceSensor {
+  export type AsObject = {
+    minimumDistanceM: number,
+    maximumDistanceM: number,
+    currentDistanceM: number,
+  }
+}
+
+export class ScaledPressure extends jspb.Message {
+  getTimestampUs(): number;
+  setTimestampUs(value: number): ScaledPressure;
+
+  getAbsolutePressureHpa(): number;
+  setAbsolutePressureHpa(value: number): ScaledPressure;
+
+  getDifferentialPressureHpa(): number;
+  setDifferentialPressureHpa(value: number): ScaledPressure;
+
+  getTemperatureDeg(): number;
+  setTemperatureDeg(value: number): ScaledPressure;
+
+  getDifferentialPressureTemperatureDeg(): number;
+  setDifferentialPressureTemperatureDeg(value: number): ScaledPressure;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ScaledPressure.AsObject;
+  static toObject(includeInstance: boolean, msg: ScaledPressure): ScaledPressure.AsObject;
+  static serializeBinaryToWriter(message: ScaledPressure, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ScaledPressure;
+  static deserializeBinaryFromReader(message: ScaledPressure, reader: jspb.BinaryReader): ScaledPressure;
+}
+
+export namespace ScaledPressure {
+  export type AsObject = {
+    timestampUs: number,
+    absolutePressureHpa: number,
+    differentialPressureHpa: number,
+    temperatureDeg: number,
+    differentialPressureTemperatureDeg: number,
+  }
+}
+
+export class PositionNed extends jspb.Message {
+  getNorthM(): number;
+  setNorthM(value: number): PositionNed;
+
+  getEastM(): number;
+  setEastM(value: number): PositionNed;
+
+  getDownM(): number;
+  setDownM(value: number): PositionNed;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PositionNed.AsObject;
+  static toObject(includeInstance: boolean, msg: PositionNed): PositionNed.AsObject;
+  static serializeBinaryToWriter(message: PositionNed, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PositionNed;
+  static deserializeBinaryFromReader(message: PositionNed, reader: jspb.BinaryReader): PositionNed;
+}
+
+export namespace PositionNed {
+  export type AsObject = {
+    northM: number,
+    eastM: number,
+    downM: number,
+  }
+}
+
+export class VelocityNed extends jspb.Message {
+  getNorthMS(): number;
+  setNorthMS(value: number): VelocityNed;
+
+  getEastMS(): number;
+  setEastMS(value: number): VelocityNed;
+
+  getDownMS(): number;
+  setDownMS(value: number): VelocityNed;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): VelocityNed.AsObject;
+  static toObject(includeInstance: boolean, msg: VelocityNed): VelocityNed.AsObject;
+  static serializeBinaryToWriter(message: VelocityNed, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): VelocityNed;
+  static deserializeBinaryFromReader(message: VelocityNed, reader: jspb.BinaryReader): VelocityNed;
+}
+
+export namespace VelocityNed {
+  export type AsObject = {
+    northMS: number,
+    eastMS: number,
+    downMS: number,
+  }
+}
+
+export class PositionVelocityNed extends jspb.Message {
+  getPosition(): PositionNed | undefined;
+  setPosition(value?: PositionNed): PositionVelocityNed;
+  hasPosition(): boolean;
+  clearPosition(): PositionVelocityNed;
+
+  getVelocity(): VelocityNed | undefined;
+  setVelocity(value?: VelocityNed): PositionVelocityNed;
+  hasVelocity(): boolean;
+  clearVelocity(): PositionVelocityNed;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PositionVelocityNed.AsObject;
+  static toObject(includeInstance: boolean, msg: PositionVelocityNed): PositionVelocityNed.AsObject;
+  static serializeBinaryToWriter(message: PositionVelocityNed, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PositionVelocityNed;
+  static deserializeBinaryFromReader(message: PositionVelocityNed, reader: jspb.BinaryReader): PositionVelocityNed;
+}
+
+export namespace PositionVelocityNed {
+  export type AsObject = {
+    position?: PositionNed.AsObject,
+    velocity?: VelocityNed.AsObject,
+  }
+}
+
+export class GroundTruth extends jspb.Message {
+  getLatitudeDeg(): number;
+  setLatitudeDeg(value: number): GroundTruth;
+
+  getLongitudeDeg(): number;
+  setLongitudeDeg(value: number): GroundTruth;
+
+  getAbsoluteAltitudeM(): number;
+  setAbsoluteAltitudeM(value: number): GroundTruth;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GroundTruth.AsObject;
+  static toObject(includeInstance: boolean, msg: GroundTruth): GroundTruth.AsObject;
+  static serializeBinaryToWriter(message: GroundTruth, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GroundTruth;
+  static deserializeBinaryFromReader(message: GroundTruth, reader: jspb.BinaryReader): GroundTruth;
+}
+
+export namespace GroundTruth {
+  export type AsObject = {
+    latitudeDeg: number,
+    longitudeDeg: number,
+    absoluteAltitudeM: number,
+  }
+}
+
+export class FixedwingMetrics extends jspb.Message {
+  getAirspeedMS(): number;
+  setAirspeedMS(value: number): FixedwingMetrics;
+
+  getThrottlePercentage(): number;
+  setThrottlePercentage(value: number): FixedwingMetrics;
+
+  getClimbRateMS(): number;
+  setClimbRateMS(value: number): FixedwingMetrics;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): FixedwingMetrics.AsObject;
+  static toObject(includeInstance: boolean, msg: FixedwingMetrics): FixedwingMetrics.AsObject;
+  static serializeBinaryToWriter(message: FixedwingMetrics, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): FixedwingMetrics;
+  static deserializeBinaryFromReader(message: FixedwingMetrics, reader: jspb.BinaryReader): FixedwingMetrics;
+}
+
+export namespace FixedwingMetrics {
+  export type AsObject = {
+    airspeedMS: number,
+    throttlePercentage: number,
+    climbRateMS: number,
+  }
+}
+
+export class AccelerationFrd extends jspb.Message {
+  getForwardMS2(): number;
+  setForwardMS2(value: number): AccelerationFrd;
+
+  getRightMS2(): number;
+  setRightMS2(value: number): AccelerationFrd;
+
+  getDownMS2(): number;
+  setDownMS2(value: number): AccelerationFrd;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AccelerationFrd.AsObject;
+  static toObject(includeInstance: boolean, msg: AccelerationFrd): AccelerationFrd.AsObject;
+  static serializeBinaryToWriter(message: AccelerationFrd, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AccelerationFrd;
+  static deserializeBinaryFromReader(message: AccelerationFrd, reader: jspb.BinaryReader): AccelerationFrd;
+}
+
+export namespace AccelerationFrd {
+  export type AsObject = {
+    forwardMS2: number,
+    rightMS2: number,
+    downMS2: number,
+  }
+}
+
+export class AngularVelocityFrd extends jspb.Message {
+  getForwardRadS(): number;
+  setForwardRadS(value: number): AngularVelocityFrd;
+
+  getRightRadS(): number;
+  setRightRadS(value: number): AngularVelocityFrd;
+
+  getDownRadS(): number;
+  setDownRadS(value: number): AngularVelocityFrd;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AngularVelocityFrd.AsObject;
+  static toObject(includeInstance: boolean, msg: AngularVelocityFrd): AngularVelocityFrd.AsObject;
+  static serializeBinaryToWriter(message: AngularVelocityFrd, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AngularVelocityFrd;
+  static deserializeBinaryFromReader(message: AngularVelocityFrd, reader: jspb.BinaryReader): AngularVelocityFrd;
+}
+
+export namespace AngularVelocityFrd {
+  export type AsObject = {
+    forwardRadS: number,
+    rightRadS: number,
+    downRadS: number,
+  }
+}
+
+export class MagneticFieldFrd extends jspb.Message {
+  getForwardGauss(): number;
+  setForwardGauss(value: number): MagneticFieldFrd;
+
+  getRightGauss(): number;
+  setRightGauss(value: number): MagneticFieldFrd;
+
+  getDownGauss(): number;
+  setDownGauss(value: number): MagneticFieldFrd;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MagneticFieldFrd.AsObject;
+  static toObject(includeInstance: boolean, msg: MagneticFieldFrd): MagneticFieldFrd.AsObject;
+  static serializeBinaryToWriter(message: MagneticFieldFrd, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MagneticFieldFrd;
+  static deserializeBinaryFromReader(message: MagneticFieldFrd, reader: jspb.BinaryReader): MagneticFieldFrd;
+}
+
+export namespace MagneticFieldFrd {
+  export type AsObject = {
+    forwardGauss: number,
+    rightGauss: number,
+    downGauss: number,
+  }
+}
+
+export class Imu extends jspb.Message {
+  getAccelerationFrd(): AccelerationFrd | undefined;
+  setAccelerationFrd(value?: AccelerationFrd): Imu;
+  hasAccelerationFrd(): boolean;
+  clearAccelerationFrd(): Imu;
+
+  getAngularVelocityFrd(): AngularVelocityFrd | undefined;
+  setAngularVelocityFrd(value?: AngularVelocityFrd): Imu;
+  hasAngularVelocityFrd(): boolean;
+  clearAngularVelocityFrd(): Imu;
+
+  getMagneticFieldFrd(): MagneticFieldFrd | undefined;
+  setMagneticFieldFrd(value?: MagneticFieldFrd): Imu;
+  hasMagneticFieldFrd(): boolean;
+  clearMagneticFieldFrd(): Imu;
+
+  getTemperatureDegc(): number;
+  setTemperatureDegc(value: number): Imu;
+
+  getTimestampUs(): number;
+  setTimestampUs(value: number): Imu;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Imu.AsObject;
+  static toObject(includeInstance: boolean, msg: Imu): Imu.AsObject;
+  static serializeBinaryToWriter(message: Imu, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Imu;
+  static deserializeBinaryFromReader(message: Imu, reader: jspb.BinaryReader): Imu;
+}
+
+export namespace Imu {
+  export type AsObject = {
+    accelerationFrd?: AccelerationFrd.AsObject,
+    angularVelocityFrd?: AngularVelocityFrd.AsObject,
+    magneticFieldFrd?: MagneticFieldFrd.AsObject,
+    temperatureDegc: number,
+    timestampUs: number,
+  }
+}
+
+export class TelemetryServerResult extends jspb.Message {
+  getResult(): TelemetryServerResult.Result;
+  setResult(value: TelemetryServerResult.Result): TelemetryServerResult;
+
+  getResultStr(): string;
+  setResultStr(value: string): TelemetryServerResult;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TelemetryServerResult.AsObject;
+  static toObject(includeInstance: boolean, msg: TelemetryServerResult): TelemetryServerResult.AsObject;
+  static serializeBinaryToWriter(message: TelemetryServerResult, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TelemetryServerResult;
+  static deserializeBinaryFromReader(message: TelemetryServerResult, reader: jspb.BinaryReader): TelemetryServerResult;
+}
+
+export namespace TelemetryServerResult {
+  export type AsObject = {
+    result: TelemetryServerResult.Result,
+    resultStr: string,
+  }
+
+  export enum Result { 
+    RESULT_UNKNOWN = 0,
+    RESULT_SUCCESS = 1,
+    RESULT_NO_SYSTEM = 2,
+    RESULT_CONNECTION_ERROR = 3,
+    RESULT_BUSY = 4,
+    RESULT_COMMAND_DENIED = 5,
+    RESULT_TIMEOUT = 6,
+    RESULT_UNSUPPORTED = 7,
+  }
+}
+
+export enum FixType { 
+  FIX_TYPE_NO_GPS = 0,
+  FIX_TYPE_NO_FIX = 1,
+  FIX_TYPE_FIX_2D = 2,
+  FIX_TYPE_FIX_3D = 3,
+  FIX_TYPE_FIX_DGPS = 4,
+  FIX_TYPE_RTK_FLOAT = 5,
+  FIX_TYPE_RTK_FIXED = 6,
+}
+export enum VtolState { 
+  VTOL_STATE_UNDEFINED = 0,
+  VTOL_STATE_TRANSITION_TO_FW = 1,
+  VTOL_STATE_TRANSITION_TO_MC = 2,
+  VTOL_STATE_MC = 3,
+  VTOL_STATE_FW = 4,
+}
+export enum StatusTextType { 
+  STATUS_TEXT_TYPE_DEBUG = 0,
+  STATUS_TEXT_TYPE_INFO = 1,
+  STATUS_TEXT_TYPE_NOTICE = 2,
+  STATUS_TEXT_TYPE_WARNING = 3,
+  STATUS_TEXT_TYPE_ERROR = 4,
+  STATUS_TEXT_TYPE_CRITICAL = 5,
+  STATUS_TEXT_TYPE_ALERT = 6,
+  STATUS_TEXT_TYPE_EMERGENCY = 7,
+}
+export enum LandedState { 
+  LANDED_STATE_UNKNOWN = 0,
+  LANDED_STATE_ON_GROUND = 1,
+  LANDED_STATE_IN_AIR = 2,
+  LANDED_STATE_TAKING_OFF = 3,
+  LANDED_STATE_LANDING = 4,
+}