mavsdk-types 1.0.0

package/calibration/CalibrationServiceClientPb.ts

@@ -0,0 +1,192 @@
+/**
+ * @fileoverview gRPC-Web generated client stub for mavsdk.rpc.calibration
+ * @enhanceable
+ * @public
+ */
+
+// GENERATED CODE -- DO NOT EDIT!
+
+
+/* eslint-disable */
+// @ts-nocheck
+
+
+import * as grpcWeb from 'grpc-web';
+
+import * as calibration_calibration_pb from '../calibration/calibration_pb';
+
+
+export class CalibrationServiceClient {
+  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;
+  }
+
+  methodDescriptorSubscribeCalibrateGyro = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateGyro',
+    grpcWeb.MethodType.SERVER_STREAMING,
+    calibration_calibration_pb.SubscribeCalibrateGyroRequest,
+    calibration_calibration_pb.CalibrateGyroResponse,
+    (request: calibration_calibration_pb.SubscribeCalibrateGyroRequest) => {
+      return request.serializeBinary();
+    },
+    calibration_calibration_pb.CalibrateGyroResponse.deserializeBinary
+  );
+
+  subscribeCalibrateGyro(
+    request: calibration_calibration_pb.SubscribeCalibrateGyroRequest,
+    metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<calibration_calibration_pb.CalibrateGyroResponse> {
+    return this.client_.serverStreaming(
+      this.hostname_ +
+        '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateGyro',
+      request,
+      metadata || {},
+      this.methodDescriptorSubscribeCalibrateGyro);
+  }
+
+  methodDescriptorSubscribeCalibrateAccelerometer = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateAccelerometer',
+    grpcWeb.MethodType.SERVER_STREAMING,
+    calibration_calibration_pb.SubscribeCalibrateAccelerometerRequest,
+    calibration_calibration_pb.CalibrateAccelerometerResponse,
+    (request: calibration_calibration_pb.SubscribeCalibrateAccelerometerRequest) => {
+      return request.serializeBinary();
+    },
+    calibration_calibration_pb.CalibrateAccelerometerResponse.deserializeBinary
+  );
+
+  subscribeCalibrateAccelerometer(
+    request: calibration_calibration_pb.SubscribeCalibrateAccelerometerRequest,
+    metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<calibration_calibration_pb.CalibrateAccelerometerResponse> {
+    return this.client_.serverStreaming(
+      this.hostname_ +
+        '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateAccelerometer',
+      request,
+      metadata || {},
+      this.methodDescriptorSubscribeCalibrateAccelerometer);
+  }
+
+  methodDescriptorSubscribeCalibrateMagnetometer = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateMagnetometer',
+    grpcWeb.MethodType.SERVER_STREAMING,
+    calibration_calibration_pb.SubscribeCalibrateMagnetometerRequest,
+    calibration_calibration_pb.CalibrateMagnetometerResponse,
+    (request: calibration_calibration_pb.SubscribeCalibrateMagnetometerRequest) => {
+      return request.serializeBinary();
+    },
+    calibration_calibration_pb.CalibrateMagnetometerResponse.deserializeBinary
+  );
+
+  subscribeCalibrateMagnetometer(
+    request: calibration_calibration_pb.SubscribeCalibrateMagnetometerRequest,
+    metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<calibration_calibration_pb.CalibrateMagnetometerResponse> {
+    return this.client_.serverStreaming(
+      this.hostname_ +
+        '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateMagnetometer',
+      request,
+      metadata || {},
+      this.methodDescriptorSubscribeCalibrateMagnetometer);
+  }
+
+  methodDescriptorSubscribeCalibrateLevelHorizon = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateLevelHorizon',
+    grpcWeb.MethodType.SERVER_STREAMING,
+    calibration_calibration_pb.SubscribeCalibrateLevelHorizonRequest,
+    calibration_calibration_pb.CalibrateLevelHorizonResponse,
+    (request: calibration_calibration_pb.SubscribeCalibrateLevelHorizonRequest) => {
+      return request.serializeBinary();
+    },
+    calibration_calibration_pb.CalibrateLevelHorizonResponse.deserializeBinary
+  );
+
+  subscribeCalibrateLevelHorizon(
+    request: calibration_calibration_pb.SubscribeCalibrateLevelHorizonRequest,
+    metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<calibration_calibration_pb.CalibrateLevelHorizonResponse> {
+    return this.client_.serverStreaming(
+      this.hostname_ +
+        '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateLevelHorizon',
+      request,
+      metadata || {},
+      this.methodDescriptorSubscribeCalibrateLevelHorizon);
+  }
+
+  methodDescriptorSubscribeCalibrateGimbalAccelerometer = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateGimbalAccelerometer',
+    grpcWeb.MethodType.SERVER_STREAMING,
+    calibration_calibration_pb.SubscribeCalibrateGimbalAccelerometerRequest,
+    calibration_calibration_pb.CalibrateGimbalAccelerometerResponse,
+    (request: calibration_calibration_pb.SubscribeCalibrateGimbalAccelerometerRequest) => {
+      return request.serializeBinary();
+    },
+    calibration_calibration_pb.CalibrateGimbalAccelerometerResponse.deserializeBinary
+  );
+
+  subscribeCalibrateGimbalAccelerometer(
+    request: calibration_calibration_pb.SubscribeCalibrateGimbalAccelerometerRequest,
+    metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<calibration_calibration_pb.CalibrateGimbalAccelerometerResponse> {
+    return this.client_.serverStreaming(
+      this.hostname_ +
+        '/mavsdk.rpc.calibration.CalibrationService/SubscribeCalibrateGimbalAccelerometer',
+      request,
+      metadata || {},
+      this.methodDescriptorSubscribeCalibrateGimbalAccelerometer);
+  }
+
+  methodDescriptorCancel = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.calibration.CalibrationService/Cancel',
+    grpcWeb.MethodType.UNARY,
+    calibration_calibration_pb.CancelRequest,
+    calibration_calibration_pb.CancelResponse,
+    (request: calibration_calibration_pb.CancelRequest) => {
+      return request.serializeBinary();
+    },
+    calibration_calibration_pb.CancelResponse.deserializeBinary
+  );
+
+  cancel(
+    request: calibration_calibration_pb.CancelRequest,
+    metadata: grpcWeb.Metadata | null): Promise<calibration_calibration_pb.CancelResponse>;
+
+  cancel(
+    request: calibration_calibration_pb.CancelRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback: (err: grpcWeb.RpcError,
+               response: calibration_calibration_pb.CancelResponse) => void): grpcWeb.ClientReadableStream<calibration_calibration_pb.CancelResponse>;
+
+  cancel(
+    request: calibration_calibration_pb.CancelRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback?: (err: grpcWeb.RpcError,
+               response: calibration_calibration_pb.CancelResponse) => void) {
+    if (callback !== undefined) {
+      return this.client_.rpcCall(
+        this.hostname_ +
+          '/mavsdk.rpc.calibration.CalibrationService/Cancel',
+        request,
+        metadata || {},
+        this.methodDescriptorCancel,
+        callback);
+    }
+    return this.client_.unaryCall(
+    this.hostname_ +
+      '/mavsdk.rpc.calibration.CalibrationService/Cancel',
+    request,
+    metadata || {},
+    this.methodDescriptorCancel);
+  }
+
+}
+

package/calibration/calibration_pb.d.ts

@@ -0,0 +1,306 @@
+import * as jspb from 'google-protobuf'
+
+import * as mavsdk_options_pb from '../mavsdk_options_pb';
+
+
+export class SubscribeCalibrateGyroRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeCalibrateGyroRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeCalibrateGyroRequest): SubscribeCalibrateGyroRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeCalibrateGyroRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeCalibrateGyroRequest;
+  static deserializeBinaryFromReader(message: SubscribeCalibrateGyroRequest, reader: jspb.BinaryReader): SubscribeCalibrateGyroRequest;
+}
+
+export namespace SubscribeCalibrateGyroRequest {
+  export type AsObject = {
+  }
+}
+
+export class CalibrateGyroResponse extends jspb.Message {
+  getCalibrationResult(): CalibrationResult | undefined;
+  setCalibrationResult(value?: CalibrationResult): CalibrateGyroResponse;
+  hasCalibrationResult(): boolean;
+  clearCalibrationResult(): CalibrateGyroResponse;
+
+  getProgressData(): ProgressData | undefined;
+  setProgressData(value?: ProgressData): CalibrateGyroResponse;
+  hasProgressData(): boolean;
+  clearProgressData(): CalibrateGyroResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CalibrateGyroResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CalibrateGyroResponse): CalibrateGyroResponse.AsObject;
+  static serializeBinaryToWriter(message: CalibrateGyroResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CalibrateGyroResponse;
+  static deserializeBinaryFromReader(message: CalibrateGyroResponse, reader: jspb.BinaryReader): CalibrateGyroResponse;
+}
+
+export namespace CalibrateGyroResponse {
+  export type AsObject = {
+    calibrationResult?: CalibrationResult.AsObject,
+    progressData?: ProgressData.AsObject,
+  }
+}
+
+export class SubscribeCalibrateAccelerometerRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeCalibrateAccelerometerRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeCalibrateAccelerometerRequest): SubscribeCalibrateAccelerometerRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeCalibrateAccelerometerRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeCalibrateAccelerometerRequest;
+  static deserializeBinaryFromReader(message: SubscribeCalibrateAccelerometerRequest, reader: jspb.BinaryReader): SubscribeCalibrateAccelerometerRequest;
+}
+
+export namespace SubscribeCalibrateAccelerometerRequest {
+  export type AsObject = {
+  }
+}
+
+export class CalibrateAccelerometerResponse extends jspb.Message {
+  getCalibrationResult(): CalibrationResult | undefined;
+  setCalibrationResult(value?: CalibrationResult): CalibrateAccelerometerResponse;
+  hasCalibrationResult(): boolean;
+  clearCalibrationResult(): CalibrateAccelerometerResponse;
+
+  getProgressData(): ProgressData | undefined;
+  setProgressData(value?: ProgressData): CalibrateAccelerometerResponse;
+  hasProgressData(): boolean;
+  clearProgressData(): CalibrateAccelerometerResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CalibrateAccelerometerResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CalibrateAccelerometerResponse): CalibrateAccelerometerResponse.AsObject;
+  static serializeBinaryToWriter(message: CalibrateAccelerometerResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CalibrateAccelerometerResponse;
+  static deserializeBinaryFromReader(message: CalibrateAccelerometerResponse, reader: jspb.BinaryReader): CalibrateAccelerometerResponse;
+}
+
+export namespace CalibrateAccelerometerResponse {
+  export type AsObject = {
+    calibrationResult?: CalibrationResult.AsObject,
+    progressData?: ProgressData.AsObject,
+  }
+}
+
+export class SubscribeCalibrateMagnetometerRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeCalibrateMagnetometerRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeCalibrateMagnetometerRequest): SubscribeCalibrateMagnetometerRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeCalibrateMagnetometerRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeCalibrateMagnetometerRequest;
+  static deserializeBinaryFromReader(message: SubscribeCalibrateMagnetometerRequest, reader: jspb.BinaryReader): SubscribeCalibrateMagnetometerRequest;
+}
+
+export namespace SubscribeCalibrateMagnetometerRequest {
+  export type AsObject = {
+  }
+}
+
+export class CalibrateMagnetometerResponse extends jspb.Message {
+  getCalibrationResult(): CalibrationResult | undefined;
+  setCalibrationResult(value?: CalibrationResult): CalibrateMagnetometerResponse;
+  hasCalibrationResult(): boolean;
+  clearCalibrationResult(): CalibrateMagnetometerResponse;
+
+  getProgressData(): ProgressData | undefined;
+  setProgressData(value?: ProgressData): CalibrateMagnetometerResponse;
+  hasProgressData(): boolean;
+  clearProgressData(): CalibrateMagnetometerResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CalibrateMagnetometerResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CalibrateMagnetometerResponse): CalibrateMagnetometerResponse.AsObject;
+  static serializeBinaryToWriter(message: CalibrateMagnetometerResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CalibrateMagnetometerResponse;
+  static deserializeBinaryFromReader(message: CalibrateMagnetometerResponse, reader: jspb.BinaryReader): CalibrateMagnetometerResponse;
+}
+
+export namespace CalibrateMagnetometerResponse {
+  export type AsObject = {
+    calibrationResult?: CalibrationResult.AsObject,
+    progressData?: ProgressData.AsObject,
+  }
+}
+
+export class SubscribeCalibrateLevelHorizonRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeCalibrateLevelHorizonRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeCalibrateLevelHorizonRequest): SubscribeCalibrateLevelHorizonRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeCalibrateLevelHorizonRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeCalibrateLevelHorizonRequest;
+  static deserializeBinaryFromReader(message: SubscribeCalibrateLevelHorizonRequest, reader: jspb.BinaryReader): SubscribeCalibrateLevelHorizonRequest;
+}
+
+export namespace SubscribeCalibrateLevelHorizonRequest {
+  export type AsObject = {
+  }
+}
+
+export class CalibrateLevelHorizonResponse extends jspb.Message {
+  getCalibrationResult(): CalibrationResult | undefined;
+  setCalibrationResult(value?: CalibrationResult): CalibrateLevelHorizonResponse;
+  hasCalibrationResult(): boolean;
+  clearCalibrationResult(): CalibrateLevelHorizonResponse;
+
+  getProgressData(): ProgressData | undefined;
+  setProgressData(value?: ProgressData): CalibrateLevelHorizonResponse;
+  hasProgressData(): boolean;
+  clearProgressData(): CalibrateLevelHorizonResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CalibrateLevelHorizonResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CalibrateLevelHorizonResponse): CalibrateLevelHorizonResponse.AsObject;
+  static serializeBinaryToWriter(message: CalibrateLevelHorizonResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CalibrateLevelHorizonResponse;
+  static deserializeBinaryFromReader(message: CalibrateLevelHorizonResponse, reader: jspb.BinaryReader): CalibrateLevelHorizonResponse;
+}
+
+export namespace CalibrateLevelHorizonResponse {
+  export type AsObject = {
+    calibrationResult?: CalibrationResult.AsObject,
+    progressData?: ProgressData.AsObject,
+  }
+}
+
+export class SubscribeCalibrateGimbalAccelerometerRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeCalibrateGimbalAccelerometerRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeCalibrateGimbalAccelerometerRequest): SubscribeCalibrateGimbalAccelerometerRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeCalibrateGimbalAccelerometerRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeCalibrateGimbalAccelerometerRequest;
+  static deserializeBinaryFromReader(message: SubscribeCalibrateGimbalAccelerometerRequest, reader: jspb.BinaryReader): SubscribeCalibrateGimbalAccelerometerRequest;
+}
+
+export namespace SubscribeCalibrateGimbalAccelerometerRequest {
+  export type AsObject = {
+  }
+}
+
+export class CalibrateGimbalAccelerometerResponse extends jspb.Message {
+  getCalibrationResult(): CalibrationResult | undefined;
+  setCalibrationResult(value?: CalibrationResult): CalibrateGimbalAccelerometerResponse;
+  hasCalibrationResult(): boolean;
+  clearCalibrationResult(): CalibrateGimbalAccelerometerResponse;
+
+  getProgressData(): ProgressData | undefined;
+  setProgressData(value?: ProgressData): CalibrateGimbalAccelerometerResponse;
+  hasProgressData(): boolean;
+  clearProgressData(): CalibrateGimbalAccelerometerResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CalibrateGimbalAccelerometerResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CalibrateGimbalAccelerometerResponse): CalibrateGimbalAccelerometerResponse.AsObject;
+  static serializeBinaryToWriter(message: CalibrateGimbalAccelerometerResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CalibrateGimbalAccelerometerResponse;
+  static deserializeBinaryFromReader(message: CalibrateGimbalAccelerometerResponse, reader: jspb.BinaryReader): CalibrateGimbalAccelerometerResponse;
+}
+
+export namespace CalibrateGimbalAccelerometerResponse {
+  export type AsObject = {
+    calibrationResult?: CalibrationResult.AsObject,
+    progressData?: ProgressData.AsObject,
+  }
+}
+
+export class CancelRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CancelRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: CancelRequest): CancelRequest.AsObject;
+  static serializeBinaryToWriter(message: CancelRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CancelRequest;
+  static deserializeBinaryFromReader(message: CancelRequest, reader: jspb.BinaryReader): CancelRequest;
+}
+
+export namespace CancelRequest {
+  export type AsObject = {
+  }
+}
+
+export class CancelResponse extends jspb.Message {
+  getCalibrationResult(): CalibrationResult | undefined;
+  setCalibrationResult(value?: CalibrationResult): CancelResponse;
+  hasCalibrationResult(): boolean;
+  clearCalibrationResult(): CancelResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CancelResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CancelResponse): CancelResponse.AsObject;
+  static serializeBinaryToWriter(message: CancelResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CancelResponse;
+  static deserializeBinaryFromReader(message: CancelResponse, reader: jspb.BinaryReader): CancelResponse;
+}
+
+export namespace CancelResponse {
+  export type AsObject = {
+    calibrationResult?: CalibrationResult.AsObject,
+  }
+}
+
+export class CalibrationResult extends jspb.Message {
+  getResult(): CalibrationResult.Result;
+  setResult(value: CalibrationResult.Result): CalibrationResult;
+
+  getResultStr(): string;
+  setResultStr(value: string): CalibrationResult;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CalibrationResult.AsObject;
+  static toObject(includeInstance: boolean, msg: CalibrationResult): CalibrationResult.AsObject;
+  static serializeBinaryToWriter(message: CalibrationResult, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CalibrationResult;
+  static deserializeBinaryFromReader(message: CalibrationResult, reader: jspb.BinaryReader): CalibrationResult;
+}
+
+export namespace CalibrationResult {
+  export type AsObject = {
+    result: CalibrationResult.Result,
+    resultStr: string,
+  }
+
+  export enum Result { 
+    RESULT_UNKNOWN = 0,
+    RESULT_SUCCESS = 1,
+    RESULT_NEXT = 2,
+    RESULT_FAILED = 3,
+    RESULT_NO_SYSTEM = 4,
+    RESULT_CONNECTION_ERROR = 5,
+    RESULT_BUSY = 6,
+    RESULT_COMMAND_DENIED = 7,
+    RESULT_TIMEOUT = 8,
+    RESULT_CANCELLED = 9,
+    RESULT_FAILED_ARMED = 10,
+    RESULT_UNSUPPORTED = 11,
+  }
+}
+
+export class ProgressData extends jspb.Message {
+  getHasProgress(): boolean;
+  setHasProgress(value: boolean): ProgressData;
+
+  getProgress(): number;
+  setProgress(value: number): ProgressData;
+
+  getHasStatusText(): boolean;
+  setHasStatusText(value: boolean): ProgressData;
+
+  getStatusText(): string;
+  setStatusText(value: string): ProgressData;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ProgressData.AsObject;
+  static toObject(includeInstance: boolean, msg: ProgressData): ProgressData.AsObject;
+  static serializeBinaryToWriter(message: ProgressData, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ProgressData;
+  static deserializeBinaryFromReader(message: ProgressData, reader: jspb.BinaryReader): ProgressData;
+}
+
+export namespace ProgressData {
+  export type AsObject = {
+    hasProgress: boolean,
+    progress: number,
+    hasStatusText: boolean,
+    statusText: string,
+  }
+}
+