mavsdk-types 1.0.0

package/mocap/MocapServiceClientPb.ts

@@ -0,0 +1,168 @@
+/**
+ * @fileoverview gRPC-Web generated client stub for mavsdk.rpc.mocap
+ * @enhanceable
+ * @public
+ */
+
+// GENERATED CODE -- DO NOT EDIT!
+
+
+/* eslint-disable */
+// @ts-nocheck
+
+
+import * as grpcWeb from 'grpc-web';
+
+import * as mocap_mocap_pb from '../mocap/mocap_pb';
+
+
+export class MocapServiceClient {
+  client_: grpcWeb.AbstractClientBase;
+  hostname_: string;
+  credentials_: null | { [index: string]: string; };
+  options_: null | { [index: string]: any; };
+
+  constructor (hostname: string,
+               credentials?: null | { [index: string]: string; },
+               options?: null | { [index: string]: any; }) {
+    if (!options) options = {};
+    if (!credentials) credentials = {};
+    options['format'] = 'text';
+
+    this.client_ = new grpcWeb.GrpcWebClientBase(options);
+    this.hostname_ = hostname;
+    this.credentials_ = credentials;
+    this.options_ = options;
+  }
+
+  methodDescriptorSetVisionPositionEstimate = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.mocap.MocapService/SetVisionPositionEstimate',
+    grpcWeb.MethodType.UNARY,
+    mocap_mocap_pb.SetVisionPositionEstimateRequest,
+    mocap_mocap_pb.SetVisionPositionEstimateResponse,
+    (request: mocap_mocap_pb.SetVisionPositionEstimateRequest) => {
+      return request.serializeBinary();
+    },
+    mocap_mocap_pb.SetVisionPositionEstimateResponse.deserializeBinary
+  );
+
+  setVisionPositionEstimate(
+    request: mocap_mocap_pb.SetVisionPositionEstimateRequest,
+    metadata: grpcWeb.Metadata | null): Promise<mocap_mocap_pb.SetVisionPositionEstimateResponse>;
+
+  setVisionPositionEstimate(
+    request: mocap_mocap_pb.SetVisionPositionEstimateRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback: (err: grpcWeb.RpcError,
+               response: mocap_mocap_pb.SetVisionPositionEstimateResponse) => void): grpcWeb.ClientReadableStream<mocap_mocap_pb.SetVisionPositionEstimateResponse>;
+
+  setVisionPositionEstimate(
+    request: mocap_mocap_pb.SetVisionPositionEstimateRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback?: (err: grpcWeb.RpcError,
+               response: mocap_mocap_pb.SetVisionPositionEstimateResponse) => void) {
+    if (callback !== undefined) {
+      return this.client_.rpcCall(
+        this.hostname_ +
+          '/mavsdk.rpc.mocap.MocapService/SetVisionPositionEstimate',
+        request,
+        metadata || {},
+        this.methodDescriptorSetVisionPositionEstimate,
+        callback);
+    }
+    return this.client_.unaryCall(
+    this.hostname_ +
+      '/mavsdk.rpc.mocap.MocapService/SetVisionPositionEstimate',
+    request,
+    metadata || {},
+    this.methodDescriptorSetVisionPositionEstimate);
+  }
+
+  methodDescriptorSetAttitudePositionMocap = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.mocap.MocapService/SetAttitudePositionMocap',
+    grpcWeb.MethodType.UNARY,
+    mocap_mocap_pb.SetAttitudePositionMocapRequest,
+    mocap_mocap_pb.SetAttitudePositionMocapResponse,
+    (request: mocap_mocap_pb.SetAttitudePositionMocapRequest) => {
+      return request.serializeBinary();
+    },
+    mocap_mocap_pb.SetAttitudePositionMocapResponse.deserializeBinary
+  );
+
+  setAttitudePositionMocap(
+    request: mocap_mocap_pb.SetAttitudePositionMocapRequest,
+    metadata: grpcWeb.Metadata | null): Promise<mocap_mocap_pb.SetAttitudePositionMocapResponse>;
+
+  setAttitudePositionMocap(
+    request: mocap_mocap_pb.SetAttitudePositionMocapRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback: (err: grpcWeb.RpcError,
+               response: mocap_mocap_pb.SetAttitudePositionMocapResponse) => void): grpcWeb.ClientReadableStream<mocap_mocap_pb.SetAttitudePositionMocapResponse>;
+
+  setAttitudePositionMocap(
+    request: mocap_mocap_pb.SetAttitudePositionMocapRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback?: (err: grpcWeb.RpcError,
+               response: mocap_mocap_pb.SetAttitudePositionMocapResponse) => void) {
+    if (callback !== undefined) {
+      return this.client_.rpcCall(
+        this.hostname_ +
+          '/mavsdk.rpc.mocap.MocapService/SetAttitudePositionMocap',
+        request,
+        metadata || {},
+        this.methodDescriptorSetAttitudePositionMocap,
+        callback);
+    }
+    return this.client_.unaryCall(
+    this.hostname_ +
+      '/mavsdk.rpc.mocap.MocapService/SetAttitudePositionMocap',
+    request,
+    metadata || {},
+    this.methodDescriptorSetAttitudePositionMocap);
+  }
+
+  methodDescriptorSetOdometry = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.mocap.MocapService/SetOdometry',
+    grpcWeb.MethodType.UNARY,
+    mocap_mocap_pb.SetOdometryRequest,
+    mocap_mocap_pb.SetOdometryResponse,
+    (request: mocap_mocap_pb.SetOdometryRequest) => {
+      return request.serializeBinary();
+    },
+    mocap_mocap_pb.SetOdometryResponse.deserializeBinary
+  );
+
+  setOdometry(
+    request: mocap_mocap_pb.SetOdometryRequest,
+    metadata: grpcWeb.Metadata | null): Promise<mocap_mocap_pb.SetOdometryResponse>;
+
+  setOdometry(
+    request: mocap_mocap_pb.SetOdometryRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback: (err: grpcWeb.RpcError,
+               response: mocap_mocap_pb.SetOdometryResponse) => void): grpcWeb.ClientReadableStream<mocap_mocap_pb.SetOdometryResponse>;
+
+  setOdometry(
+    request: mocap_mocap_pb.SetOdometryRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback?: (err: grpcWeb.RpcError,
+               response: mocap_mocap_pb.SetOdometryResponse) => void) {
+    if (callback !== undefined) {
+      return this.client_.rpcCall(
+        this.hostname_ +
+          '/mavsdk.rpc.mocap.MocapService/SetOdometry',
+        request,
+        metadata || {},
+        this.methodDescriptorSetOdometry,
+        callback);
+    }
+    return this.client_.unaryCall(
+    this.hostname_ +
+      '/mavsdk.rpc.mocap.MocapService/SetOdometry',
+    request,
+    metadata || {},
+    this.methodDescriptorSetOdometry);
+  }
+
+}
+

package/mocap/mocap_pb.d.ts

@@ -0,0 +1,445 @@
+import * as jspb from 'google-protobuf'
+
+import * as mavsdk_options_pb from '../mavsdk_options_pb';
+
+
+export class SetVisionPositionEstimateRequest extends jspb.Message {
+  getVisionPositionEstimate(): VisionPositionEstimate | undefined;
+  setVisionPositionEstimate(value?: VisionPositionEstimate): SetVisionPositionEstimateRequest;
+  hasVisionPositionEstimate(): boolean;
+  clearVisionPositionEstimate(): SetVisionPositionEstimateRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetVisionPositionEstimateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SetVisionPositionEstimateRequest): SetVisionPositionEstimateRequest.AsObject;
+  static serializeBinaryToWriter(message: SetVisionPositionEstimateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetVisionPositionEstimateRequest;
+  static deserializeBinaryFromReader(message: SetVisionPositionEstimateRequest, reader: jspb.BinaryReader): SetVisionPositionEstimateRequest;
+}
+
+export namespace SetVisionPositionEstimateRequest {
+  export type AsObject = {
+    visionPositionEstimate?: VisionPositionEstimate.AsObject,
+  }
+}
+
+export class SetVisionPositionEstimateResponse extends jspb.Message {
+  getMocapResult(): MocapResult | undefined;
+  setMocapResult(value?: MocapResult): SetVisionPositionEstimateResponse;
+  hasMocapResult(): boolean;
+  clearMocapResult(): SetVisionPositionEstimateResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetVisionPositionEstimateResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: SetVisionPositionEstimateResponse): SetVisionPositionEstimateResponse.AsObject;
+  static serializeBinaryToWriter(message: SetVisionPositionEstimateResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetVisionPositionEstimateResponse;
+  static deserializeBinaryFromReader(message: SetVisionPositionEstimateResponse, reader: jspb.BinaryReader): SetVisionPositionEstimateResponse;
+}
+
+export namespace SetVisionPositionEstimateResponse {
+  export type AsObject = {
+    mocapResult?: MocapResult.AsObject,
+  }
+}
+
+export class SetAttitudePositionMocapRequest extends jspb.Message {
+  getAttitudePositionMocap(): AttitudePositionMocap | undefined;
+  setAttitudePositionMocap(value?: AttitudePositionMocap): SetAttitudePositionMocapRequest;
+  hasAttitudePositionMocap(): boolean;
+  clearAttitudePositionMocap(): SetAttitudePositionMocapRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetAttitudePositionMocapRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SetAttitudePositionMocapRequest): SetAttitudePositionMocapRequest.AsObject;
+  static serializeBinaryToWriter(message: SetAttitudePositionMocapRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetAttitudePositionMocapRequest;
+  static deserializeBinaryFromReader(message: SetAttitudePositionMocapRequest, reader: jspb.BinaryReader): SetAttitudePositionMocapRequest;
+}
+
+export namespace SetAttitudePositionMocapRequest {
+  export type AsObject = {
+    attitudePositionMocap?: AttitudePositionMocap.AsObject,
+  }
+}
+
+export class SetAttitudePositionMocapResponse extends jspb.Message {
+  getMocapResult(): MocapResult | undefined;
+  setMocapResult(value?: MocapResult): SetAttitudePositionMocapResponse;
+  hasMocapResult(): boolean;
+  clearMocapResult(): SetAttitudePositionMocapResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetAttitudePositionMocapResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: SetAttitudePositionMocapResponse): SetAttitudePositionMocapResponse.AsObject;
+  static serializeBinaryToWriter(message: SetAttitudePositionMocapResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetAttitudePositionMocapResponse;
+  static deserializeBinaryFromReader(message: SetAttitudePositionMocapResponse, reader: jspb.BinaryReader): SetAttitudePositionMocapResponse;
+}
+
+export namespace SetAttitudePositionMocapResponse {
+  export type AsObject = {
+    mocapResult?: MocapResult.AsObject,
+  }
+}
+
+export class SetOdometryRequest extends jspb.Message {
+  getOdometry(): Odometry | undefined;
+  setOdometry(value?: Odometry): SetOdometryRequest;
+  hasOdometry(): boolean;
+  clearOdometry(): SetOdometryRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetOdometryRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SetOdometryRequest): SetOdometryRequest.AsObject;
+  static serializeBinaryToWriter(message: SetOdometryRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetOdometryRequest;
+  static deserializeBinaryFromReader(message: SetOdometryRequest, reader: jspb.BinaryReader): SetOdometryRequest;
+}
+
+export namespace SetOdometryRequest {
+  export type AsObject = {
+    odometry?: Odometry.AsObject,
+  }
+}
+
+export class SetOdometryResponse extends jspb.Message {
+  getMocapResult(): MocapResult | undefined;
+  setMocapResult(value?: MocapResult): SetOdometryResponse;
+  hasMocapResult(): boolean;
+  clearMocapResult(): SetOdometryResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetOdometryResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: SetOdometryResponse): SetOdometryResponse.AsObject;
+  static serializeBinaryToWriter(message: SetOdometryResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetOdometryResponse;
+  static deserializeBinaryFromReader(message: SetOdometryResponse, reader: jspb.BinaryReader): SetOdometryResponse;
+}
+
+export namespace SetOdometryResponse {
+  export type AsObject = {
+    mocapResult?: MocapResult.AsObject,
+  }
+}
+
+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 AngleBody extends jspb.Message {
+  getRollRad(): number;
+  setRollRad(value: number): AngleBody;
+
+  getPitchRad(): number;
+  setPitchRad(value: number): AngleBody;
+
+  getYawRad(): number;
+  setYawRad(value: number): AngleBody;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AngleBody.AsObject;
+  static toObject(includeInstance: boolean, msg: AngleBody): AngleBody.AsObject;
+  static serializeBinaryToWriter(message: AngleBody, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AngleBody;
+  static deserializeBinaryFromReader(message: AngleBody, reader: jspb.BinaryReader): AngleBody;
+}
+
+export namespace AngleBody {
+  export type AsObject = {
+    rollRad: number,
+    pitchRad: number,
+    yawRad: number,
+  }
+}
+
+export class SpeedBody extends jspb.Message {
+  getXMS(): number;
+  setXMS(value: number): SpeedBody;
+
+  getYMS(): number;
+  setYMS(value: number): SpeedBody;
+
+  getZMS(): number;
+  setZMS(value: number): SpeedBody;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SpeedBody.AsObject;
+  static toObject(includeInstance: boolean, msg: SpeedBody): SpeedBody.AsObject;
+  static serializeBinaryToWriter(message: SpeedBody, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SpeedBody;
+  static deserializeBinaryFromReader(message: SpeedBody, reader: jspb.BinaryReader): SpeedBody;
+}
+
+export namespace SpeedBody {
+  export type AsObject = {
+    xMS: number,
+    yMS: number,
+    zMS: 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 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 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;
+
+  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,
+  }
+}
+
+export class VisionPositionEstimate extends jspb.Message {
+  getTimeUsec(): number;
+  setTimeUsec(value: number): VisionPositionEstimate;
+
+  getPositionBody(): PositionBody | undefined;
+  setPositionBody(value?: PositionBody): VisionPositionEstimate;
+  hasPositionBody(): boolean;
+  clearPositionBody(): VisionPositionEstimate;
+
+  getAngleBody(): AngleBody | undefined;
+  setAngleBody(value?: AngleBody): VisionPositionEstimate;
+  hasAngleBody(): boolean;
+  clearAngleBody(): VisionPositionEstimate;
+
+  getPoseCovariance(): Covariance | undefined;
+  setPoseCovariance(value?: Covariance): VisionPositionEstimate;
+  hasPoseCovariance(): boolean;
+  clearPoseCovariance(): VisionPositionEstimate;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): VisionPositionEstimate.AsObject;
+  static toObject(includeInstance: boolean, msg: VisionPositionEstimate): VisionPositionEstimate.AsObject;
+  static serializeBinaryToWriter(message: VisionPositionEstimate, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): VisionPositionEstimate;
+  static deserializeBinaryFromReader(message: VisionPositionEstimate, reader: jspb.BinaryReader): VisionPositionEstimate;
+}
+
+export namespace VisionPositionEstimate {
+  export type AsObject = {
+    timeUsec: number,
+    positionBody?: PositionBody.AsObject,
+    angleBody?: AngleBody.AsObject,
+    poseCovariance?: Covariance.AsObject,
+  }
+}
+
+export class AttitudePositionMocap extends jspb.Message {
+  getTimeUsec(): number;
+  setTimeUsec(value: number): AttitudePositionMocap;
+
+  getQ(): Quaternion | undefined;
+  setQ(value?: Quaternion): AttitudePositionMocap;
+  hasQ(): boolean;
+  clearQ(): AttitudePositionMocap;
+
+  getPositionBody(): PositionBody | undefined;
+  setPositionBody(value?: PositionBody): AttitudePositionMocap;
+  hasPositionBody(): boolean;
+  clearPositionBody(): AttitudePositionMocap;
+
+  getPoseCovariance(): Covariance | undefined;
+  setPoseCovariance(value?: Covariance): AttitudePositionMocap;
+  hasPoseCovariance(): boolean;
+  clearPoseCovariance(): AttitudePositionMocap;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AttitudePositionMocap.AsObject;
+  static toObject(includeInstance: boolean, msg: AttitudePositionMocap): AttitudePositionMocap.AsObject;
+  static serializeBinaryToWriter(message: AttitudePositionMocap, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AttitudePositionMocap;
+  static deserializeBinaryFromReader(message: AttitudePositionMocap, reader: jspb.BinaryReader): AttitudePositionMocap;
+}
+
+export namespace AttitudePositionMocap {
+  export type AsObject = {
+    timeUsec: number,
+    q?: Quaternion.AsObject,
+    positionBody?: PositionBody.AsObject,
+    poseCovariance?: Covariance.AsObject,
+  }
+}
+
+export class Odometry extends jspb.Message {
+  getTimeUsec(): number;
+  setTimeUsec(value: number): Odometry;
+
+  getFrameId(): Odometry.MavFrame;
+  setFrameId(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;
+
+  getSpeedBody(): SpeedBody | undefined;
+  setSpeedBody(value?: SpeedBody): Odometry;
+  hasSpeedBody(): boolean;
+  clearSpeedBody(): 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,
+    positionBody?: PositionBody.AsObject,
+    q?: Quaternion.AsObject,
+    speedBody?: SpeedBody.AsObject,
+    angularVelocityBody?: AngularVelocityBody.AsObject,
+    poseCovariance?: Covariance.AsObject,
+    velocityCovariance?: Covariance.AsObject,
+  }
+
+  export enum MavFrame { 
+    MAV_FRAME_MOCAP_NED = 0,
+    MAV_FRAME_LOCAL_FRD = 1,
+  }
+}
+
+export class MocapResult extends jspb.Message {
+  getResult(): MocapResult.Result;
+  setResult(value: MocapResult.Result): MocapResult;
+
+  getResultStr(): string;
+  setResultStr(value: string): MocapResult;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MocapResult.AsObject;
+  static toObject(includeInstance: boolean, msg: MocapResult): MocapResult.AsObject;
+  static serializeBinaryToWriter(message: MocapResult, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MocapResult;
+  static deserializeBinaryFromReader(message: MocapResult, reader: jspb.BinaryReader): MocapResult;
+}
+
+export namespace MocapResult {
+  export type AsObject = {
+    result: MocapResult.Result,
+    resultStr: string,
+  }
+
+  export enum Result { 
+    RESULT_UNKNOWN = 0,
+    RESULT_SUCCESS = 1,
+    RESULT_NO_SYSTEM = 2,
+    RESULT_CONNECTION_ERROR = 3,
+    RESULT_INVALID_REQUEST_DATA = 4,
+    RESULT_UNSUPPORTED = 5,
+  }
+}
+