mavsdk-types 1.0.0

package/camera/camera_pb.d.ts

@@ -0,0 +1,1260 @@
+import * as jspb from 'google-protobuf'
+
+import * as mavsdk_options_pb from '../mavsdk_options_pb';
+
+
+export class PrepareRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PrepareRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: PrepareRequest): PrepareRequest.AsObject;
+  static serializeBinaryToWriter(message: PrepareRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PrepareRequest;
+  static deserializeBinaryFromReader(message: PrepareRequest, reader: jspb.BinaryReader): PrepareRequest;
+}
+
+export namespace PrepareRequest {
+  export type AsObject = {
+  }
+}
+
+export class PrepareResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): PrepareResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): PrepareResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PrepareResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PrepareResponse): PrepareResponse.AsObject;
+  static serializeBinaryToWriter(message: PrepareResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PrepareResponse;
+  static deserializeBinaryFromReader(message: PrepareResponse, reader: jspb.BinaryReader): PrepareResponse;
+}
+
+export namespace PrepareResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class TakePhotoRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TakePhotoRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: TakePhotoRequest): TakePhotoRequest.AsObject;
+  static serializeBinaryToWriter(message: TakePhotoRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TakePhotoRequest;
+  static deserializeBinaryFromReader(message: TakePhotoRequest, reader: jspb.BinaryReader): TakePhotoRequest;
+}
+
+export namespace TakePhotoRequest {
+  export type AsObject = {
+  }
+}
+
+export class TakePhotoResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): TakePhotoResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): TakePhotoResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TakePhotoResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: TakePhotoResponse): TakePhotoResponse.AsObject;
+  static serializeBinaryToWriter(message: TakePhotoResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TakePhotoResponse;
+  static deserializeBinaryFromReader(message: TakePhotoResponse, reader: jspb.BinaryReader): TakePhotoResponse;
+}
+
+export namespace TakePhotoResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class StartPhotoIntervalRequest extends jspb.Message {
+  getIntervalS(): number;
+  setIntervalS(value: number): StartPhotoIntervalRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StartPhotoIntervalRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StartPhotoIntervalRequest): StartPhotoIntervalRequest.AsObject;
+  static serializeBinaryToWriter(message: StartPhotoIntervalRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StartPhotoIntervalRequest;
+  static deserializeBinaryFromReader(message: StartPhotoIntervalRequest, reader: jspb.BinaryReader): StartPhotoIntervalRequest;
+}
+
+export namespace StartPhotoIntervalRequest {
+  export type AsObject = {
+    intervalS: number,
+  }
+}
+
+export class StartPhotoIntervalResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): StartPhotoIntervalResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): StartPhotoIntervalResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StartPhotoIntervalResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StartPhotoIntervalResponse): StartPhotoIntervalResponse.AsObject;
+  static serializeBinaryToWriter(message: StartPhotoIntervalResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StartPhotoIntervalResponse;
+  static deserializeBinaryFromReader(message: StartPhotoIntervalResponse, reader: jspb.BinaryReader): StartPhotoIntervalResponse;
+}
+
+export namespace StartPhotoIntervalResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class StopPhotoIntervalRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StopPhotoIntervalRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StopPhotoIntervalRequest): StopPhotoIntervalRequest.AsObject;
+  static serializeBinaryToWriter(message: StopPhotoIntervalRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StopPhotoIntervalRequest;
+  static deserializeBinaryFromReader(message: StopPhotoIntervalRequest, reader: jspb.BinaryReader): StopPhotoIntervalRequest;
+}
+
+export namespace StopPhotoIntervalRequest {
+  export type AsObject = {
+  }
+}
+
+export class StopPhotoIntervalResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): StopPhotoIntervalResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): StopPhotoIntervalResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StopPhotoIntervalResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StopPhotoIntervalResponse): StopPhotoIntervalResponse.AsObject;
+  static serializeBinaryToWriter(message: StopPhotoIntervalResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StopPhotoIntervalResponse;
+  static deserializeBinaryFromReader(message: StopPhotoIntervalResponse, reader: jspb.BinaryReader): StopPhotoIntervalResponse;
+}
+
+export namespace StopPhotoIntervalResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class StartVideoRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StartVideoRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StartVideoRequest): StartVideoRequest.AsObject;
+  static serializeBinaryToWriter(message: StartVideoRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StartVideoRequest;
+  static deserializeBinaryFromReader(message: StartVideoRequest, reader: jspb.BinaryReader): StartVideoRequest;
+}
+
+export namespace StartVideoRequest {
+  export type AsObject = {
+  }
+}
+
+export class StartVideoResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): StartVideoResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): StartVideoResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StartVideoResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StartVideoResponse): StartVideoResponse.AsObject;
+  static serializeBinaryToWriter(message: StartVideoResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StartVideoResponse;
+  static deserializeBinaryFromReader(message: StartVideoResponse, reader: jspb.BinaryReader): StartVideoResponse;
+}
+
+export namespace StartVideoResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class StopVideoRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StopVideoRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StopVideoRequest): StopVideoRequest.AsObject;
+  static serializeBinaryToWriter(message: StopVideoRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StopVideoRequest;
+  static deserializeBinaryFromReader(message: StopVideoRequest, reader: jspb.BinaryReader): StopVideoRequest;
+}
+
+export namespace StopVideoRequest {
+  export type AsObject = {
+  }
+}
+
+export class StopVideoResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): StopVideoResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): StopVideoResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StopVideoResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StopVideoResponse): StopVideoResponse.AsObject;
+  static serializeBinaryToWriter(message: StopVideoResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StopVideoResponse;
+  static deserializeBinaryFromReader(message: StopVideoResponse, reader: jspb.BinaryReader): StopVideoResponse;
+}
+
+export namespace StopVideoResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class StartVideoStreamingRequest extends jspb.Message {
+  getStreamId(): number;
+  setStreamId(value: number): StartVideoStreamingRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StartVideoStreamingRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StartVideoStreamingRequest): StartVideoStreamingRequest.AsObject;
+  static serializeBinaryToWriter(message: StartVideoStreamingRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StartVideoStreamingRequest;
+  static deserializeBinaryFromReader(message: StartVideoStreamingRequest, reader: jspb.BinaryReader): StartVideoStreamingRequest;
+}
+
+export namespace StartVideoStreamingRequest {
+  export type AsObject = {
+    streamId: number,
+  }
+}
+
+export class StartVideoStreamingResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): StartVideoStreamingResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): StartVideoStreamingResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StartVideoStreamingResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StartVideoStreamingResponse): StartVideoStreamingResponse.AsObject;
+  static serializeBinaryToWriter(message: StartVideoStreamingResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StartVideoStreamingResponse;
+  static deserializeBinaryFromReader(message: StartVideoStreamingResponse, reader: jspb.BinaryReader): StartVideoStreamingResponse;
+}
+
+export namespace StartVideoStreamingResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class StopVideoStreamingRequest extends jspb.Message {
+  getStreamId(): number;
+  setStreamId(value: number): StopVideoStreamingRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StopVideoStreamingRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StopVideoStreamingRequest): StopVideoStreamingRequest.AsObject;
+  static serializeBinaryToWriter(message: StopVideoStreamingRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StopVideoStreamingRequest;
+  static deserializeBinaryFromReader(message: StopVideoStreamingRequest, reader: jspb.BinaryReader): StopVideoStreamingRequest;
+}
+
+export namespace StopVideoStreamingRequest {
+  export type AsObject = {
+    streamId: number,
+  }
+}
+
+export class StopVideoStreamingResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): StopVideoStreamingResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): StopVideoStreamingResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StopVideoStreamingResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StopVideoStreamingResponse): StopVideoStreamingResponse.AsObject;
+  static serializeBinaryToWriter(message: StopVideoStreamingResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StopVideoStreamingResponse;
+  static deserializeBinaryFromReader(message: StopVideoStreamingResponse, reader: jspb.BinaryReader): StopVideoStreamingResponse;
+}
+
+export namespace StopVideoStreamingResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class SetModeRequest extends jspb.Message {
+  getMode(): Mode;
+  setMode(value: Mode): SetModeRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetModeRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SetModeRequest): SetModeRequest.AsObject;
+  static serializeBinaryToWriter(message: SetModeRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetModeRequest;
+  static deserializeBinaryFromReader(message: SetModeRequest, reader: jspb.BinaryReader): SetModeRequest;
+}
+
+export namespace SetModeRequest {
+  export type AsObject = {
+    mode: Mode,
+  }
+}
+
+export class SetModeResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): SetModeResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): SetModeResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetModeResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: SetModeResponse): SetModeResponse.AsObject;
+  static serializeBinaryToWriter(message: SetModeResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetModeResponse;
+  static deserializeBinaryFromReader(message: SetModeResponse, reader: jspb.BinaryReader): SetModeResponse;
+}
+
+export namespace SetModeResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class ListPhotosRequest extends jspb.Message {
+  getPhotosRange(): PhotosRange;
+  setPhotosRange(value: PhotosRange): ListPhotosRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListPhotosRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ListPhotosRequest): ListPhotosRequest.AsObject;
+  static serializeBinaryToWriter(message: ListPhotosRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListPhotosRequest;
+  static deserializeBinaryFromReader(message: ListPhotosRequest, reader: jspb.BinaryReader): ListPhotosRequest;
+}
+
+export namespace ListPhotosRequest {
+  export type AsObject = {
+    photosRange: PhotosRange,
+  }
+}
+
+export class ListPhotosResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): ListPhotosResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): ListPhotosResponse;
+
+  getCaptureInfosList(): Array<CaptureInfo>;
+  setCaptureInfosList(value: Array<CaptureInfo>): ListPhotosResponse;
+  clearCaptureInfosList(): ListPhotosResponse;
+  addCaptureInfos(value?: CaptureInfo, index?: number): CaptureInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListPhotosResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ListPhotosResponse): ListPhotosResponse.AsObject;
+  static serializeBinaryToWriter(message: ListPhotosResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListPhotosResponse;
+  static deserializeBinaryFromReader(message: ListPhotosResponse, reader: jspb.BinaryReader): ListPhotosResponse;
+}
+
+export namespace ListPhotosResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+    captureInfosList: Array<CaptureInfo.AsObject>,
+  }
+}
+
+export class SubscribeInformationRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeInformationRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeInformationRequest): SubscribeInformationRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeInformationRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeInformationRequest;
+  static deserializeBinaryFromReader(message: SubscribeInformationRequest, reader: jspb.BinaryReader): SubscribeInformationRequest;
+}
+
+export namespace SubscribeInformationRequest {
+  export type AsObject = {
+  }
+}
+
+export class InformationResponse extends jspb.Message {
+  getInformation(): Information | undefined;
+  setInformation(value?: Information): InformationResponse;
+  hasInformation(): boolean;
+  clearInformation(): InformationResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): InformationResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: InformationResponse): InformationResponse.AsObject;
+  static serializeBinaryToWriter(message: InformationResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): InformationResponse;
+  static deserializeBinaryFromReader(message: InformationResponse, reader: jspb.BinaryReader): InformationResponse;
+}
+
+export namespace InformationResponse {
+  export type AsObject = {
+    information?: Information.AsObject,
+  }
+}
+
+export class SubscribeModeRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeModeRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeModeRequest): SubscribeModeRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeModeRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeModeRequest;
+  static deserializeBinaryFromReader(message: SubscribeModeRequest, reader: jspb.BinaryReader): SubscribeModeRequest;
+}
+
+export namespace SubscribeModeRequest {
+  export type AsObject = {
+  }
+}
+
+export class ModeResponse extends jspb.Message {
+  getMode(): Mode;
+  setMode(value: Mode): ModeResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ModeResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ModeResponse): ModeResponse.AsObject;
+  static serializeBinaryToWriter(message: ModeResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ModeResponse;
+  static deserializeBinaryFromReader(message: ModeResponse, reader: jspb.BinaryReader): ModeResponse;
+}
+
+export namespace ModeResponse {
+  export type AsObject = {
+    mode: Mode,
+  }
+}
+
+export class SubscribeVideoStreamInfoRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeVideoStreamInfoRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeVideoStreamInfoRequest): SubscribeVideoStreamInfoRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeVideoStreamInfoRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeVideoStreamInfoRequest;
+  static deserializeBinaryFromReader(message: SubscribeVideoStreamInfoRequest, reader: jspb.BinaryReader): SubscribeVideoStreamInfoRequest;
+}
+
+export namespace SubscribeVideoStreamInfoRequest {
+  export type AsObject = {
+  }
+}
+
+export class VideoStreamInfoResponse extends jspb.Message {
+  getVideoStreamInfo(): VideoStreamInfo | undefined;
+  setVideoStreamInfo(value?: VideoStreamInfo): VideoStreamInfoResponse;
+  hasVideoStreamInfo(): boolean;
+  clearVideoStreamInfo(): VideoStreamInfoResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): VideoStreamInfoResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: VideoStreamInfoResponse): VideoStreamInfoResponse.AsObject;
+  static serializeBinaryToWriter(message: VideoStreamInfoResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): VideoStreamInfoResponse;
+  static deserializeBinaryFromReader(message: VideoStreamInfoResponse, reader: jspb.BinaryReader): VideoStreamInfoResponse;
+}
+
+export namespace VideoStreamInfoResponse {
+  export type AsObject = {
+    videoStreamInfo?: VideoStreamInfo.AsObject,
+  }
+}
+
+export class SubscribeCaptureInfoRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeCaptureInfoRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeCaptureInfoRequest): SubscribeCaptureInfoRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeCaptureInfoRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeCaptureInfoRequest;
+  static deserializeBinaryFromReader(message: SubscribeCaptureInfoRequest, reader: jspb.BinaryReader): SubscribeCaptureInfoRequest;
+}
+
+export namespace SubscribeCaptureInfoRequest {
+  export type AsObject = {
+  }
+}
+
+export class CaptureInfoResponse extends jspb.Message {
+  getCaptureInfo(): CaptureInfo | undefined;
+  setCaptureInfo(value?: CaptureInfo): CaptureInfoResponse;
+  hasCaptureInfo(): boolean;
+  clearCaptureInfo(): CaptureInfoResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CaptureInfoResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CaptureInfoResponse): CaptureInfoResponse.AsObject;
+  static serializeBinaryToWriter(message: CaptureInfoResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CaptureInfoResponse;
+  static deserializeBinaryFromReader(message: CaptureInfoResponse, reader: jspb.BinaryReader): CaptureInfoResponse;
+}
+
+export namespace CaptureInfoResponse {
+  export type AsObject = {
+    captureInfo?: CaptureInfo.AsObject,
+  }
+}
+
+export class SubscribeStatusRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeStatusRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeStatusRequest): SubscribeStatusRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeStatusRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeStatusRequest;
+  static deserializeBinaryFromReader(message: SubscribeStatusRequest, reader: jspb.BinaryReader): SubscribeStatusRequest;
+}
+
+export namespace SubscribeStatusRequest {
+  export type AsObject = {
+  }
+}
+
+export class StatusResponse extends jspb.Message {
+  getCameraStatus(): Status | undefined;
+  setCameraStatus(value?: Status): StatusResponse;
+  hasCameraStatus(): boolean;
+  clearCameraStatus(): StatusResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StatusResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: StatusResponse): StatusResponse.AsObject;
+  static serializeBinaryToWriter(message: StatusResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StatusResponse;
+  static deserializeBinaryFromReader(message: StatusResponse, reader: jspb.BinaryReader): StatusResponse;
+}
+
+export namespace StatusResponse {
+  export type AsObject = {
+    cameraStatus?: Status.AsObject,
+  }
+}
+
+export class SubscribeCurrentSettingsRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribeCurrentSettingsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribeCurrentSettingsRequest): SubscribeCurrentSettingsRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribeCurrentSettingsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribeCurrentSettingsRequest;
+  static deserializeBinaryFromReader(message: SubscribeCurrentSettingsRequest, reader: jspb.BinaryReader): SubscribeCurrentSettingsRequest;
+}
+
+export namespace SubscribeCurrentSettingsRequest {
+  export type AsObject = {
+  }
+}
+
+export class CurrentSettingsResponse extends jspb.Message {
+  getCurrentSettingsList(): Array<Setting>;
+  setCurrentSettingsList(value: Array<Setting>): CurrentSettingsResponse;
+  clearCurrentSettingsList(): CurrentSettingsResponse;
+  addCurrentSettings(value?: Setting, index?: number): Setting;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CurrentSettingsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: CurrentSettingsResponse): CurrentSettingsResponse.AsObject;
+  static serializeBinaryToWriter(message: CurrentSettingsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CurrentSettingsResponse;
+  static deserializeBinaryFromReader(message: CurrentSettingsResponse, reader: jspb.BinaryReader): CurrentSettingsResponse;
+}
+
+export namespace CurrentSettingsResponse {
+  export type AsObject = {
+    currentSettingsList: Array<Setting.AsObject>,
+  }
+}
+
+export class SubscribePossibleSettingOptionsRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SubscribePossibleSettingOptionsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SubscribePossibleSettingOptionsRequest): SubscribePossibleSettingOptionsRequest.AsObject;
+  static serializeBinaryToWriter(message: SubscribePossibleSettingOptionsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SubscribePossibleSettingOptionsRequest;
+  static deserializeBinaryFromReader(message: SubscribePossibleSettingOptionsRequest, reader: jspb.BinaryReader): SubscribePossibleSettingOptionsRequest;
+}
+
+export namespace SubscribePossibleSettingOptionsRequest {
+  export type AsObject = {
+  }
+}
+
+export class PossibleSettingOptionsResponse extends jspb.Message {
+  getSettingOptionsList(): Array<SettingOptions>;
+  setSettingOptionsList(value: Array<SettingOptions>): PossibleSettingOptionsResponse;
+  clearSettingOptionsList(): PossibleSettingOptionsResponse;
+  addSettingOptions(value?: SettingOptions, index?: number): SettingOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PossibleSettingOptionsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: PossibleSettingOptionsResponse): PossibleSettingOptionsResponse.AsObject;
+  static serializeBinaryToWriter(message: PossibleSettingOptionsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PossibleSettingOptionsResponse;
+  static deserializeBinaryFromReader(message: PossibleSettingOptionsResponse, reader: jspb.BinaryReader): PossibleSettingOptionsResponse;
+}
+
+export namespace PossibleSettingOptionsResponse {
+  export type AsObject = {
+    settingOptionsList: Array<SettingOptions.AsObject>,
+  }
+}
+
+export class SetSettingRequest extends jspb.Message {
+  getSetting(): Setting | undefined;
+  setSetting(value?: Setting): SetSettingRequest;
+  hasSetting(): boolean;
+  clearSetting(): SetSettingRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetSettingRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SetSettingRequest): SetSettingRequest.AsObject;
+  static serializeBinaryToWriter(message: SetSettingRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetSettingRequest;
+  static deserializeBinaryFromReader(message: SetSettingRequest, reader: jspb.BinaryReader): SetSettingRequest;
+}
+
+export namespace SetSettingRequest {
+  export type AsObject = {
+    setting?: Setting.AsObject,
+  }
+}
+
+export class SetSettingResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): SetSettingResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): SetSettingResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SetSettingResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: SetSettingResponse): SetSettingResponse.AsObject;
+  static serializeBinaryToWriter(message: SetSettingResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SetSettingResponse;
+  static deserializeBinaryFromReader(message: SetSettingResponse, reader: jspb.BinaryReader): SetSettingResponse;
+}
+
+export namespace SetSettingResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class GetSettingRequest extends jspb.Message {
+  getSetting(): Setting | undefined;
+  setSetting(value?: Setting): GetSettingRequest;
+  hasSetting(): boolean;
+  clearSetting(): GetSettingRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetSettingRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetSettingRequest): GetSettingRequest.AsObject;
+  static serializeBinaryToWriter(message: GetSettingRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetSettingRequest;
+  static deserializeBinaryFromReader(message: GetSettingRequest, reader: jspb.BinaryReader): GetSettingRequest;
+}
+
+export namespace GetSettingRequest {
+  export type AsObject = {
+    setting?: Setting.AsObject,
+  }
+}
+
+export class GetSettingResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): GetSettingResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): GetSettingResponse;
+
+  getSetting(): Setting | undefined;
+  setSetting(value?: Setting): GetSettingResponse;
+  hasSetting(): boolean;
+  clearSetting(): GetSettingResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetSettingResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetSettingResponse): GetSettingResponse.AsObject;
+  static serializeBinaryToWriter(message: GetSettingResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetSettingResponse;
+  static deserializeBinaryFromReader(message: GetSettingResponse, reader: jspb.BinaryReader): GetSettingResponse;
+}
+
+export namespace GetSettingResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+    setting?: Setting.AsObject,
+  }
+}
+
+export class FormatStorageRequest extends jspb.Message {
+  getStorageId(): number;
+  setStorageId(value: number): FormatStorageRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): FormatStorageRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: FormatStorageRequest): FormatStorageRequest.AsObject;
+  static serializeBinaryToWriter(message: FormatStorageRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): FormatStorageRequest;
+  static deserializeBinaryFromReader(message: FormatStorageRequest, reader: jspb.BinaryReader): FormatStorageRequest;
+}
+
+export namespace FormatStorageRequest {
+  export type AsObject = {
+    storageId: number,
+  }
+}
+
+export class FormatStorageResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): FormatStorageResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): FormatStorageResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): FormatStorageResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: FormatStorageResponse): FormatStorageResponse.AsObject;
+  static serializeBinaryToWriter(message: FormatStorageResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): FormatStorageResponse;
+  static deserializeBinaryFromReader(message: FormatStorageResponse, reader: jspb.BinaryReader): FormatStorageResponse;
+}
+
+export namespace FormatStorageResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class SelectCameraResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): SelectCameraResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): SelectCameraResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SelectCameraResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: SelectCameraResponse): SelectCameraResponse.AsObject;
+  static serializeBinaryToWriter(message: SelectCameraResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SelectCameraResponse;
+  static deserializeBinaryFromReader(message: SelectCameraResponse, reader: jspb.BinaryReader): SelectCameraResponse;
+}
+
+export namespace SelectCameraResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class SelectCameraRequest extends jspb.Message {
+  getCameraId(): number;
+  setCameraId(value: number): SelectCameraRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SelectCameraRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: SelectCameraRequest): SelectCameraRequest.AsObject;
+  static serializeBinaryToWriter(message: SelectCameraRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SelectCameraRequest;
+  static deserializeBinaryFromReader(message: SelectCameraRequest, reader: jspb.BinaryReader): SelectCameraRequest;
+}
+
+export namespace SelectCameraRequest {
+  export type AsObject = {
+    cameraId: number,
+  }
+}
+
+export class ResetSettingsRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ResetSettingsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ResetSettingsRequest): ResetSettingsRequest.AsObject;
+  static serializeBinaryToWriter(message: ResetSettingsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ResetSettingsRequest;
+  static deserializeBinaryFromReader(message: ResetSettingsRequest, reader: jspb.BinaryReader): ResetSettingsRequest;
+}
+
+export namespace ResetSettingsRequest {
+  export type AsObject = {
+  }
+}
+
+export class ResetSettingsResponse extends jspb.Message {
+  getCameraResult(): CameraResult | undefined;
+  setCameraResult(value?: CameraResult): ResetSettingsResponse;
+  hasCameraResult(): boolean;
+  clearCameraResult(): ResetSettingsResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ResetSettingsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ResetSettingsResponse): ResetSettingsResponse.AsObject;
+  static serializeBinaryToWriter(message: ResetSettingsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ResetSettingsResponse;
+  static deserializeBinaryFromReader(message: ResetSettingsResponse, reader: jspb.BinaryReader): ResetSettingsResponse;
+}
+
+export namespace ResetSettingsResponse {
+  export type AsObject = {
+    cameraResult?: CameraResult.AsObject,
+  }
+}
+
+export class CameraResult extends jspb.Message {
+  getResult(): CameraResult.Result;
+  setResult(value: CameraResult.Result): CameraResult;
+
+  getResultStr(): string;
+  setResultStr(value: string): CameraResult;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CameraResult.AsObject;
+  static toObject(includeInstance: boolean, msg: CameraResult): CameraResult.AsObject;
+  static serializeBinaryToWriter(message: CameraResult, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CameraResult;
+  static deserializeBinaryFromReader(message: CameraResult, reader: jspb.BinaryReader): CameraResult;
+}
+
+export namespace CameraResult {
+  export type AsObject = {
+    result: CameraResult.Result,
+    resultStr: string,
+  }
+
+  export enum Result { 
+    RESULT_UNKNOWN = 0,
+    RESULT_SUCCESS = 1,
+    RESULT_IN_PROGRESS = 2,
+    RESULT_BUSY = 3,
+    RESULT_DENIED = 4,
+    RESULT_ERROR = 5,
+    RESULT_TIMEOUT = 6,
+    RESULT_WRONG_ARGUMENT = 7,
+    RESULT_NO_SYSTEM = 8,
+    RESULT_PROTOCOL_UNSUPPORTED = 9,
+  }
+}
+
+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 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 EulerAngle extends jspb.Message {
+  getRollDeg(): number;
+  setRollDeg(value: number): EulerAngle;
+
+  getPitchDeg(): number;
+  setPitchDeg(value: number): EulerAngle;
+
+  getYawDeg(): number;
+  setYawDeg(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,
+  }
+}
+
+export class CaptureInfo extends jspb.Message {
+  getPosition(): Position | undefined;
+  setPosition(value?: Position): CaptureInfo;
+  hasPosition(): boolean;
+  clearPosition(): CaptureInfo;
+
+  getAttitudeQuaternion(): Quaternion | undefined;
+  setAttitudeQuaternion(value?: Quaternion): CaptureInfo;
+  hasAttitudeQuaternion(): boolean;
+  clearAttitudeQuaternion(): CaptureInfo;
+
+  getAttitudeEulerAngle(): EulerAngle | undefined;
+  setAttitudeEulerAngle(value?: EulerAngle): CaptureInfo;
+  hasAttitudeEulerAngle(): boolean;
+  clearAttitudeEulerAngle(): CaptureInfo;
+
+  getTimeUtcUs(): number;
+  setTimeUtcUs(value: number): CaptureInfo;
+
+  getIsSuccess(): boolean;
+  setIsSuccess(value: boolean): CaptureInfo;
+
+  getIndex(): number;
+  setIndex(value: number): CaptureInfo;
+
+  getFileUrl(): string;
+  setFileUrl(value: string): CaptureInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CaptureInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: CaptureInfo): CaptureInfo.AsObject;
+  static serializeBinaryToWriter(message: CaptureInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CaptureInfo;
+  static deserializeBinaryFromReader(message: CaptureInfo, reader: jspb.BinaryReader): CaptureInfo;
+}
+
+export namespace CaptureInfo {
+  export type AsObject = {
+    position?: Position.AsObject,
+    attitudeQuaternion?: Quaternion.AsObject,
+    attitudeEulerAngle?: EulerAngle.AsObject,
+    timeUtcUs: number,
+    isSuccess: boolean,
+    index: number,
+    fileUrl: string,
+  }
+}
+
+export class VideoStreamSettings extends jspb.Message {
+  getFrameRateHz(): number;
+  setFrameRateHz(value: number): VideoStreamSettings;
+
+  getHorizontalResolutionPix(): number;
+  setHorizontalResolutionPix(value: number): VideoStreamSettings;
+
+  getVerticalResolutionPix(): number;
+  setVerticalResolutionPix(value: number): VideoStreamSettings;
+
+  getBitRateBS(): number;
+  setBitRateBS(value: number): VideoStreamSettings;
+
+  getRotationDeg(): number;
+  setRotationDeg(value: number): VideoStreamSettings;
+
+  getUri(): string;
+  setUri(value: string): VideoStreamSettings;
+
+  getHorizontalFovDeg(): number;
+  setHorizontalFovDeg(value: number): VideoStreamSettings;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): VideoStreamSettings.AsObject;
+  static toObject(includeInstance: boolean, msg: VideoStreamSettings): VideoStreamSettings.AsObject;
+  static serializeBinaryToWriter(message: VideoStreamSettings, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): VideoStreamSettings;
+  static deserializeBinaryFromReader(message: VideoStreamSettings, reader: jspb.BinaryReader): VideoStreamSettings;
+}
+
+export namespace VideoStreamSettings {
+  export type AsObject = {
+    frameRateHz: number,
+    horizontalResolutionPix: number,
+    verticalResolutionPix: number,
+    bitRateBS: number,
+    rotationDeg: number,
+    uri: string,
+    horizontalFovDeg: number,
+  }
+}
+
+export class VideoStreamInfo extends jspb.Message {
+  getSettings(): VideoStreamSettings | undefined;
+  setSettings(value?: VideoStreamSettings): VideoStreamInfo;
+  hasSettings(): boolean;
+  clearSettings(): VideoStreamInfo;
+
+  getStatus(): VideoStreamInfo.VideoStreamStatus;
+  setStatus(value: VideoStreamInfo.VideoStreamStatus): VideoStreamInfo;
+
+  getSpectrum(): VideoStreamInfo.VideoStreamSpectrum;
+  setSpectrum(value: VideoStreamInfo.VideoStreamSpectrum): VideoStreamInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): VideoStreamInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: VideoStreamInfo): VideoStreamInfo.AsObject;
+  static serializeBinaryToWriter(message: VideoStreamInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): VideoStreamInfo;
+  static deserializeBinaryFromReader(message: VideoStreamInfo, reader: jspb.BinaryReader): VideoStreamInfo;
+}
+
+export namespace VideoStreamInfo {
+  export type AsObject = {
+    settings?: VideoStreamSettings.AsObject,
+    status: VideoStreamInfo.VideoStreamStatus,
+    spectrum: VideoStreamInfo.VideoStreamSpectrum,
+  }
+
+  export enum VideoStreamStatus { 
+    VIDEO_STREAM_STATUS_NOT_RUNNING = 0,
+    VIDEO_STREAM_STATUS_IN_PROGRESS = 1,
+  }
+
+  export enum VideoStreamSpectrum { 
+    VIDEO_STREAM_SPECTRUM_UNKNOWN = 0,
+    VIDEO_STREAM_SPECTRUM_VISIBLE_LIGHT = 1,
+    VIDEO_STREAM_SPECTRUM_INFRARED = 2,
+  }
+}
+
+export class Status extends jspb.Message {
+  getVideoOn(): boolean;
+  setVideoOn(value: boolean): Status;
+
+  getPhotoIntervalOn(): boolean;
+  setPhotoIntervalOn(value: boolean): Status;
+
+  getUsedStorageMib(): number;
+  setUsedStorageMib(value: number): Status;
+
+  getAvailableStorageMib(): number;
+  setAvailableStorageMib(value: number): Status;
+
+  getTotalStorageMib(): number;
+  setTotalStorageMib(value: number): Status;
+
+  getRecordingTimeS(): number;
+  setRecordingTimeS(value: number): Status;
+
+  getMediaFolderName(): string;
+  setMediaFolderName(value: string): Status;
+
+  getStorageStatus(): Status.StorageStatus;
+  setStorageStatus(value: Status.StorageStatus): Status;
+
+  getStorageId(): number;
+  setStorageId(value: number): Status;
+
+  getStorageType(): Status.StorageType;
+  setStorageType(value: Status.StorageType): Status;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Status.AsObject;
+  static toObject(includeInstance: boolean, msg: Status): Status.AsObject;
+  static serializeBinaryToWriter(message: Status, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Status;
+  static deserializeBinaryFromReader(message: Status, reader: jspb.BinaryReader): Status;
+}
+
+export namespace Status {
+  export type AsObject = {
+    videoOn: boolean,
+    photoIntervalOn: boolean,
+    usedStorageMib: number,
+    availableStorageMib: number,
+    totalStorageMib: number,
+    recordingTimeS: number,
+    mediaFolderName: string,
+    storageStatus: Status.StorageStatus,
+    storageId: number,
+    storageType: Status.StorageType,
+  }
+
+  export enum StorageStatus { 
+    STORAGE_STATUS_NOT_AVAILABLE = 0,
+    STORAGE_STATUS_UNFORMATTED = 1,
+    STORAGE_STATUS_FORMATTED = 2,
+    STORAGE_STATUS_NOT_SUPPORTED = 3,
+  }
+
+  export enum StorageType { 
+    STORAGE_TYPE_UNKNOWN = 0,
+    STORAGE_TYPE_USB_STICK = 1,
+    STORAGE_TYPE_SD = 2,
+    STORAGE_TYPE_MICROSD = 3,
+    STORAGE_TYPE_HD = 7,
+    STORAGE_TYPE_OTHER = 254,
+  }
+}
+
+export class Option extends jspb.Message {
+  getOptionId(): string;
+  setOptionId(value: string): Option;
+
+  getOptionDescription(): string;
+  setOptionDescription(value: string): Option;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Option.AsObject;
+  static toObject(includeInstance: boolean, msg: Option): Option.AsObject;
+  static serializeBinaryToWriter(message: Option, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Option;
+  static deserializeBinaryFromReader(message: Option, reader: jspb.BinaryReader): Option;
+}
+
+export namespace Option {
+  export type AsObject = {
+    optionId: string,
+    optionDescription: string,
+  }
+}
+
+export class Setting extends jspb.Message {
+  getSettingId(): string;
+  setSettingId(value: string): Setting;
+
+  getSettingDescription(): string;
+  setSettingDescription(value: string): Setting;
+
+  getOption(): Option | undefined;
+  setOption(value?: Option): Setting;
+  hasOption(): boolean;
+  clearOption(): Setting;
+
+  getIsRange(): boolean;
+  setIsRange(value: boolean): Setting;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Setting.AsObject;
+  static toObject(includeInstance: boolean, msg: Setting): Setting.AsObject;
+  static serializeBinaryToWriter(message: Setting, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Setting;
+  static deserializeBinaryFromReader(message: Setting, reader: jspb.BinaryReader): Setting;
+}
+
+export namespace Setting {
+  export type AsObject = {
+    settingId: string,
+    settingDescription: string,
+    option?: Option.AsObject,
+    isRange: boolean,
+  }
+}
+
+export class SettingOptions extends jspb.Message {
+  getSettingId(): string;
+  setSettingId(value: string): SettingOptions;
+
+  getSettingDescription(): string;
+  setSettingDescription(value: string): SettingOptions;
+
+  getOptionsList(): Array<Option>;
+  setOptionsList(value: Array<Option>): SettingOptions;
+  clearOptionsList(): SettingOptions;
+  addOptions(value?: Option, index?: number): Option;
+
+  getIsRange(): boolean;
+  setIsRange(value: boolean): SettingOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SettingOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: SettingOptions): SettingOptions.AsObject;
+  static serializeBinaryToWriter(message: SettingOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SettingOptions;
+  static deserializeBinaryFromReader(message: SettingOptions, reader: jspb.BinaryReader): SettingOptions;
+}
+
+export namespace SettingOptions {
+  export type AsObject = {
+    settingId: string,
+    settingDescription: string,
+    optionsList: Array<Option.AsObject>,
+    isRange: boolean,
+  }
+}
+
+export class Information extends jspb.Message {
+  getVendorName(): string;
+  setVendorName(value: string): Information;
+
+  getModelName(): string;
+  setModelName(value: string): Information;
+
+  getFocalLengthMm(): number;
+  setFocalLengthMm(value: number): Information;
+
+  getHorizontalSensorSizeMm(): number;
+  setHorizontalSensorSizeMm(value: number): Information;
+
+  getVerticalSensorSizeMm(): number;
+  setVerticalSensorSizeMm(value: number): Information;
+
+  getHorizontalResolutionPx(): number;
+  setHorizontalResolutionPx(value: number): Information;
+
+  getVerticalResolutionPx(): number;
+  setVerticalResolutionPx(value: number): Information;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Information.AsObject;
+  static toObject(includeInstance: boolean, msg: Information): Information.AsObject;
+  static serializeBinaryToWriter(message: Information, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Information;
+  static deserializeBinaryFromReader(message: Information, reader: jspb.BinaryReader): Information;
+}
+
+export namespace Information {
+  export type AsObject = {
+    vendorName: string,
+    modelName: string,
+    focalLengthMm: number,
+    horizontalSensorSizeMm: number,
+    verticalSensorSizeMm: number,
+    horizontalResolutionPx: number,
+    verticalResolutionPx: number,
+  }
+}
+
+export enum Mode { 
+  MODE_UNKNOWN = 0,
+  MODE_PHOTO = 1,
+  MODE_VIDEO = 2,
+}
+export enum PhotosRange { 
+  PHOTOS_RANGE_ALL = 0,
+  PHOTOS_RANGE_SINCE_CONNECTION = 1,
+}